@stream-io/feeds-client 0.2.18 → 0.2.20

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

@@ -1,268 +0,0 @@
-import type {
-  FollowResponse,
-  FeedResponse,
-  UserResponse,
-} from '../../../gen/models';
-import { generateFollowResponse } from '../../../test-utils';
-import { updateStateFollowDeleted } from './handle-follow-deleted';
-
-import { describe, it, expect, beforeEach } from 'vitest';
-
-describe('handle-follow-deleted', () => {
-  describe(updateStateFollowDeleted.name, () => {
-    let mockFollow: FollowResponse;
-    let mockFeed: FeedResponse;
-    let mockUser: UserResponse;
-
-    beforeEach(() => {
-      mockFollow = generateFollowResponse();
-      mockFeed = mockFollow.source_feed;
-      mockUser = mockFeed.created_by;
-    });
-
-    it('should handle when this feed unfollows someone', () => {
-      const existingFollow: FollowResponse = {
-        ...mockFollow,
-        source_feed: {
-          ...mockFeed,
-          id: 'feed-1',
-          feed: 'user:feed-1',
-          created_by: mockUser,
-        },
-        target_feed: {
-          ...mockFeed,
-          id: 'other-feed',
-          feed: 'user:other-feed',
-          created_by: mockUser,
-        },
-      };
-
-      const follow: FollowResponse = existingFollow;
-
-      // @ts-expect-error - we're not testing the full state here
-      const currentState: FeedState = {
-        following: [existingFollow],
-        following_count: 1,
-      };
-
-      const result = updateStateFollowDeleted(
-        follow,
-        currentState,
-        'user:feed-1',
-        'user-1',
-      );
-
-      expect(result.changed).toBe(true);
-      expect(result.data.following).toHaveLength(0);
-      expect(result.data).toMatchObject(follow.source_feed);
-    });
-
-    it('should handle when someone unfollows this feed', () => {
-      const existingFollow: 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,
-        },
-      };
-
-      const follow: FollowResponse = existingFollow;
-
-      // @ts-expect-error - we're not testing the full state here
-      const currentState: FeedState = {
-        followers: [existingFollow],
-        own_follows: [existingFollow],
-        following_count: 1,
-      };
-
-      const result = updateStateFollowDeleted(
-        follow,
-        currentState,
-        'user:feed-1',
-        'user-1',
-      );
-
-      expect(result.changed).toBe(true);
-      expect(result.data.followers).toHaveLength(0);
-      expect(result.data.own_follows).toBe(currentState.own_follows);
-      expect(result.data).toMatchObject(follow.target_feed);
-    });
-
-    it('should only remove own_follows when connected user is the source', () => {
-      const existingFollow: FollowResponse = {
-        ...mockFollow,
-        source_feed: {
-          ...mockFeed,
-          id: 'other-feed',
-          feed: 'user:other-feed',
-          created_by: { ...mockUser, id: 'user-1' },
-        },
-        target_feed: {
-          ...mockFeed,
-          id: 'feed-1',
-          feed: 'user:feed-1',
-          created_by: mockUser,
-        },
-      };
-
-      const follow: FollowResponse = existingFollow;
-
-      // @ts-expect-error - we're not testing the full state here
-      const currentState: FeedState = {
-        followers: [existingFollow],
-        own_follows: [existingFollow],
-        following_count: 1,
-      };
-
-      const result = updateStateFollowDeleted(
-        follow,
-        currentState,
-        'user:feed-1',
-        'user-1',
-      );
-
-      expect(result.changed).toBe(true);
-      expect(result.data.followers).toHaveLength(0);
-      expect(result.data.own_follows).toHaveLength(0);
-    });
-
-    it('should not remove own_follows when connected user is not the source', () => {
-      const existingFollow: 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,
-        },
-      };
-
-      const follow: FollowResponse = existingFollow;
-
-      // @ts-expect-error - we're not testing the full state here
-      const currentState: FeedState = {
-        followers: [existingFollow],
-        own_follows: [existingFollow],
-      };
-
-      const result = updateStateFollowDeleted(
-        follow,
-        currentState,
-        'user:feed-1',
-        'user-1',
-      );
-
-      expect(result.changed).toBe(true);
-      expect(result.data.followers).toHaveLength(0);
-      expect(result.data.own_follows).toHaveLength(1); // Should remain unchanged
-    });
-
-    it('should not update followers/following when they are undefined in delete', () => {
-      const existingFollow: 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,
-        },
-      };
-
-      const follow: FollowResponse = existingFollow;
-
-      // @ts-expect-error - we're not testing the full state here
-      const currentState: FeedState = {
-        followers: undefined,
-        own_follows: undefined,
-      };
-
-      const result = updateStateFollowDeleted(
-        follow,
-        currentState,
-        'user:feed-1',
-        'user-1',
-      );
-
-      expect(result.changed).toBe(true);
-      expect(result.data.followers).toBeUndefined();
-      expect(result.data.own_follows).toBeUndefined();
-      expect(result.data).toMatchObject(follow.target_feed);
-    });
-
-    it('should filter out the correct follow by target feed id', () => {
-      const followToRemove: FollowResponse = {
-        ...mockFollow,
-        source_feed: {
-          ...mockFeed,
-          id: 'feed-1',
-          feed: 'user:feed-1',
-          created_by: mockUser,
-        },
-        target_feed: {
-          ...mockFeed,
-          id: 'target-to-remove',
-          feed: 'user:target-to-remove',
-          created_by: mockUser,
-        },
-      };
-
-      const followToKeep: FollowResponse = {
-        ...mockFollow,
-        source_feed: {
-          ...mockFeed,
-          id: 'feed-1',
-          feed: 'user:feed-1',
-          created_by: mockUser,
-        },
-        target_feed: {
-          ...mockFeed,
-          id: 'target-to-keep',
-          feed: 'user:target-to-keep',
-          created_by: mockUser,
-        },
-      };
-
-      const follow: FollowResponse = followToRemove;
-
-      // @ts-expect-error - we're not testing the full state here
-      const currentState: FeedState = {
-        following: [followToRemove, followToKeep],
-        following_count: 2,
-      };
-
-      const result = updateStateFollowDeleted(
-        follow,
-        currentState,
-        'user:feed-1',
-        'user-1',
-      );
-
-      expect(result.changed).toBe(true);
-      expect(result.data.following).toHaveLength(1);
-      expect(result.data.following?.[0]).toBe(followToKeep);
-    });
-  });
-});

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

@@ -1,131 +0,0 @@
-import { describe, it, expect, beforeEach } from 'vitest';
-import { Feed } from '../../../feed';
-import { FeedsClient } from '../../../feeds-client';
-import { handleFollowUpdated } from './handle-follow-updated';
-import {
-  generateFollowResponse,
-  generateFeedResponse,
-  getHumanId,
-  generateOwnUser,
-} from '../../../test-utils/response-generators';
-import type { FollowResponse } from '../../../gen/models';
-
-describe(handleFollowUpdated.name, () => {
-  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],
-    }));
-  });
-
-  it('updates a follow in following when this feed is the source', () => {
-    const updatedFollow: FollowResponse = { ...follow, status: 'pending' };
-
-    handleFollowUpdated.call(feed, { follow: updatedFollow });
-
-    const [updatedFollowAfter] = feed.currentState.following!;
-
-    expect(updatedFollowAfter).toBe(updatedFollow);
-  });
-
-  it('updates a follow in followers when this feed is the target', () => {
-    const updatedOtherFollow: FollowResponse = {
-      ...otherFollow,
-      status: 'rejected',
-    };
-
-    handleFollowUpdated.call(feed, { follow: updatedOtherFollow });
-
-    const [updatedOtherFollowAfter] = feed.currentState.followers!;
-
-    expect(updatedOtherFollowAfter).toBe(updatedOtherFollow);
-  });
-
-  it('updates a follow in own_follows when connected user is the creator', () => {
-    const updatedOwnFollow: FollowResponse = {
-      ...ownFollow,
-      status: 'pending',
-    };
-
-    handleFollowUpdated.call(feed, { follow: updatedOwnFollow });
-
-    const [ownFollowAfter] = feed.currentState.own_follows!;
-
-    expect(ownFollowAfter).toBe(updatedOwnFollow);
-  });
-
-  it('does not update if follow is not found', () => {
-    const unrelatedFollow = generateFollowResponse();
-
-    const stateBefore = feed.currentState;
-
-    handleFollowUpdated.call(feed, { follow: unrelatedFollow });
-
-    const stateAfter = feed.currentState;
-
-    expect(stateAfter.own_follows).toBe(stateBefore.own_follows);
-    expect(stateAfter.followers).toBe(stateBefore.followers);
-    expect(stateAfter.follower_count).toBe(stateBefore.follower_count);
-    expect(stateAfter.following).toBe(stateBefore.following);
-    expect(stateAfter.following_count).toBe(stateBefore.following_count);
-  });
-});

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

@@ -1,182 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  updateNotificationFeedFromEvent,
-  updateNotificationStatus,
-} from './handle-notification-feed-updated';
-import {
-  createMockAggregatedActivity,
-  createMockNotificationFeedUpdatedEvent,
-  createMockNotificationStatus,
-} from '../../../test-utils';
-
-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, [], {
-        unread: 0,
-        unseen: 0,
-        read_activities: [],
-        seen_activities: [],
-      });
-
-      expect(result.changed).toBe(false);
-    });
-
-    it(`should update notification_status when event has notification_status and currentNotificationStatus is undefined`, () => {
-      const event = createMockNotificationFeedUpdatedEvent({
-        notification_status: createMockNotificationStatus(),
-      });
-      const result = updateNotificationFeedFromEvent(event, [], undefined);
-
-      expect(result.changed).toBe(true);
-      expect(result.data?.notification_status).toStrictEqual(
-        event.notification_status,
-      );
-    });
-
-    it(`shouldn't update aggregated_activities when event has aggregated_activities but currentAggregatedActivities is undefined`, () => {
-      const event = createMockNotificationFeedUpdatedEvent({
-        aggregated_activities: [createMockAggregatedActivity()],
-      });
-      const result = updateNotificationFeedFromEvent(
-        event,
-        undefined,
-        createMockNotificationStatus(),
-      );
-
-      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'],
-        seen_activities: [],
-      });
-      const event = createMockNotificationFeedUpdatedEvent({
-        notification_status: notificationStatus,
-      });
-
-      const result = updateNotificationFeedFromEvent(event, [], {
-        unread: 0,
-        unseen: 0,
-        read_activities: [],
-        seen_activities: [],
-      });
-
-      expect(result.changed).toBe(true);
-      expect(result.data?.notification_status).toStrictEqual(
-        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, [], {
-        unread: 0,
-        unseen: 0,
-        read_activities: [],
-        seen_activities: [],
-      });
-
-      expect(result.changed).toBe(true);
-      expect(result.data?.aggregated_activities).toStrictEqual(
-        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, [], {
-        unread: 0,
-        unseen: 0,
-        read_activities: [],
-        seen_activities: [],
-      });
-
-      expect(result.changed).toBe(true);
-      expect(result.data?.notification_status?.unread).toBe(
-        notificationStatus.unread,
-      );
-      expect(result.data?.notification_status?.unseen).toBe(
-        notificationStatus.unseen,
-      );
-      expect(result.data?.aggregated_activities).toStrictEqual(
-        aggregatedActivities,
-      );
-    });
-
-    it('should handle notification_status with all fields', () => {
-      const notificationStatus = createMockNotificationStatus({
-        unread: 10,
-        unseen: 5,
-        last_seen_at: new Date('2023-01-01'),
-        seen_activities: [],
-        read_activities: ['activity1', 'activity2', 'activity3'],
-      });
-      const event = createMockNotificationFeedUpdatedEvent({
-        notification_status: notificationStatus,
-      });
-
-      const result = updateNotificationFeedFromEvent(event, [], {
-        unread: 0,
-        unseen: 0,
-        read_activities: [],
-        seen_activities: [],
-      });
-
-      expect(result.changed).toBe(true);
-      expect(result.data?.notification_status).toStrictEqual(
-        notificationStatus,
-      );
-    });
-  });
-
-  describe('updateNotificationStatus', () => {
-    it('should replace old state with new one', () => {
-      const newNotificationStatus = createMockNotificationStatus({
-        unread: 5,
-        unseen: 3,
-        read_activities: ['activity1', 'activity2'],
-        seen_activities: ['activity3', 'activity4'],
-      });
-
-      const currentNotificationStatus = createMockNotificationStatus({
-        unread: 2,
-        unseen: 1,
-        read_activities: ['activity5', 'activity6'],
-        seen_activities: ['activity7', 'activity8'],
-      });
-
-      const result = updateNotificationStatus(
-        newNotificationStatus,
-        currentNotificationStatus,
-      );
-
-      expect(result.notification_status).toStrictEqual(newNotificationStatus);
-    });
-  });
-});

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

@@ -1,45 +0,0 @@
-import {
-  generateActivityResponse,
-  generateFeedReactionResponse,
-} from '../../../test-utils';
-import { updateActivities } from './handle-story-feeds-updated';
-import { describe, expect, it } from 'vitest';
-
-describe('updateActivities', () => {
-  it('should return unchanged if new activities is empty', () => {
-    const currentActivities = [generateActivityResponse({ id: 'activity1' })];
-    const result = updateActivities([], currentActivities);
-    expect(result.changed).toBe(false);
-  });
-
-  it('should return unchanged if current activities is undefined', () => {
-    const newActivities = [generateActivityResponse({ id: 'activity1' })];
-    const result = updateActivities(newActivities, undefined);
-    expect(result.changed).toBe(false);
-  });
-
-  it('should update existing activities, ignore new ones', () => {
-    const newActivities = [
-      generateActivityResponse({ id: 'activity1', is_watched: true }),
-      generateActivityResponse({ id: 'activity3' }),
-    ];
-    const currentActivities = [
-      generateActivityResponse({
-        id: 'activity1',
-        own_reactions: [generateFeedReactionResponse({ type: 'like' })],
-      }),
-      generateActivityResponse({
-        id: 'activity2',
-      }),
-    ];
-
-    const result = updateActivities(newActivities, currentActivities);
-
-    expect(result.changed).toBe(true);
-    expect(result.activities).toHaveLength(2);
-    expect(result.activities[0].own_reactions).toHaveLength(1);
-    expect(result.activities[0].own_reactions[0].type).toBe('like');
-    expect(result.activities[0].is_watched).toBe(true);
-    expect(result.activities[1].id).toBe('activity2');
-  });
-});