@stream-io/feeds-client 0.2.17 → 0.2.19

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/feed.test.ts

@@ -1,90 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest';
-import { FeedsClient } from '../feeds-client';
-import { Feed } from './feed';
-import type { ActivityResponse } from '../gen/models';
-import { generateActivityResponse, generateFeedResponse } from '../test-utils';
-
-describe('Feed derived state updates', () => {
-  let feed: Feed;
-  let client: FeedsClient;
-  let activities: ActivityResponse[];
-
-  beforeEach(() => {
-    client = new FeedsClient('mock-api-key');
-    const feedResponse = generateFeedResponse({ id: 'main', group_id: 'user' });
-    feed = new Feed(
-      client,
-      feedResponse.group_id,
-      feedResponse.id,
-      feedResponse,
-    );
-    activities = [
-      generateActivityResponse(),
-      generateActivityResponse(),
-      generateActivityResponse(),
-    ];
-  });
-
-  it('should update the cache if activities change in feed.state', () => {
-    let indexedActivityIds = (feed as any).indexedActivityIds;
-    expect(indexedActivityIds.size).toEqual(0);
-
-    feed.state.partialNext({ activities });
-
-    indexedActivityIds = (feed as any).indexedActivityIds;
-    expect(indexedActivityIds.size).toEqual(3);
-    for (const activity of activities) {
-      expect(indexedActivityIds.has(activity.id)).toBe(true);
-    }
-  });
-
-  it('should update the cache if activities are further updated', () => {
-    // Include all of them
-    feed.state.partialNext({ activities });
-
-    let indexedActivityIds = (feed as any).indexedActivityIds;
-    expect(indexedActivityIds.size).toEqual(3);
-    for (const activity of activities) {
-      expect(indexedActivityIds.has(activity.id)).toBe(true);
-    }
-
-    // Take only the last 2
-    const newActivities = activities.slice(1);
-    feed.state.partialNext({ activities: newActivities });
-
-    indexedActivityIds = (feed as any).indexedActivityIds;
-    expect((feed as any).indexedActivityIds.size).toEqual(2);
-    for (const activity of newActivities) {
-      expect(indexedActivityIds.has(activity.id)).toBe(true);
-    }
-
-    // Include all of them again
-    feed.state.partialNext({ activities });
-
-    indexedActivityIds = (feed as any).indexedActivityIds;
-    expect(indexedActivityIds.size).toEqual(3);
-    for (const activity of activities) {
-      expect(indexedActivityIds.has(activity.id)).toBe(true);
-    }
-  });
-
-  it('should not update the cache if the length of activities has not changed', () => {
-    feed.state.partialNext({ activities });
-
-    const indexedActivityIdsBefore = (feed as any).indexedActivityIds;
-    expect(indexedActivityIdsBefore.size).toEqual(3);
-    for (const activity of activities) {
-      expect(indexedActivityIdsBefore.has(activity.id)).toBe(true);
-    }
-
-    const reversedActivities = activities.toReversed();
-    feed.state.partialNext({ activities: reversedActivities });
-
-    const indexedActivityIdsAfter = (feed as any).indexedActivityIds;
-    expect(indexedActivityIdsAfter.size).toEqual(3);
-    for (const activity of activities) {
-      expect(indexedActivityIdsAfter.has(activity.id)).toBe(true);
-    }
-    expect(indexedActivityIdsBefore).toBe(indexedActivityIdsAfter);
-  });
-});

package/src/feeds-client/event-handlers/user/handle-user-updated.test.ts

@@ -1,53 +0,0 @@
-import { describe, it, beforeEach, expect } from 'vitest';
-
-import { FeedsClient, handleUserUpdated } from '../..';
-import { generateOwnUser, generateUserResponse } from '../../../test-utils';
-import type { EventPayload } from '../../../types-internal';
-
-describe('handleUserUpdated', () => {
-  let feedsClient: FeedsClient;
-
-  beforeEach(() => {
-    feedsClient = new FeedsClient('mock-api-key');
-    const connectedUser = generateOwnUser();
-
-    feedsClient.state.partialNext({ connected_user: connectedUser });
-  });
-
-  it('should update the connected user in the state', () => {
-    const stateBefore = feedsClient.state.getLatestValue();
-
-    const event: EventPayload<'user.updated'> = {
-      type: 'user.updated',
-      created_at: new Date(),
-      custom: {},
-      user: {
-        ...generateUserResponse(),
-        ...stateBefore.connected_user!,
-      },
-    };
-
-    handleUserUpdated.call(feedsClient, event);
-
-    const stateAfter = feedsClient.state.getLatestValue();
-
-    expect(stateAfter.connected_user).toMatchObject({ name: event.user.name });
-  });
-
-  it('should not update the connected user if the incoming event contains other user', () => {
-    const event: EventPayload<'user.updated'> = {
-      type: 'user.updated',
-      created_at: new Date(),
-      custom: {},
-      user: generateUserResponse(),
-    };
-
-    const stateBefore = feedsClient.state.getLatestValue();
-
-    handleUserUpdated.call(feedsClient, event);
-
-    const stateAfter = feedsClient.state.getLatestValue();
-
-    expect(stateAfter.connected_user).toBe(stateBefore.connected_user);
-  });
-});

package/src/utils/event-triggered-by-connected-user.test.ts

@@ -1,73 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-import { eventTriggeredByConnectedUser as eventTriggeredByConnectedUserInternal } from './event-triggered-by-connected-user';
-import { FeedsClient } from '../feeds-client';
-import { Feed } from '../feed';
-import {
-  generateFeedResponse,
-  generateOwnUser, generateUserResponse,
-  getHumanId,
-} from '../test-utils';
-
-describe('eventTriggeredByConnectedUser', () => {
-  let feed: Feed;
-  let client: FeedsClient;
-  let currentUserId: string;
-
-  let eventTriggeredByConnectedUser: OmitThisParameter<typeof eventTriggeredByConnectedUserInternal>
-
-  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,
-    );
-
-    eventTriggeredByConnectedUser = eventTriggeredByConnectedUserInternal.bind(feed);
-  });
-
-  afterEach(() => {
-    vi.resetAllMocks();
-  })
-
-  it('returns true when payload.user.id matches connected_user.id', () => {
-    const user = generateUserResponse({ id: currentUserId });
-    const result = eventTriggeredByConnectedUser({ user });
-    expect(result).toBe(true);
-  });
-
-  it('returns true when payload.user is undefined and connected_user exists', () => {
-    const result = eventTriggeredByConnectedUser({});
-    expect(result).toBe(true);
-  });
-
-  it('returns false when payload.user.id differs from connected_user.id', () => {
-    const user = generateUserResponse({ id: getHumanId() });
-    const result = eventTriggeredByConnectedUser({ user });
-    expect(result).toBe(false);
-  });
-
-  it('returns false when connected_user is undefined (even if payload.user present)', () => {
-    // @ts-expect-error using protected value only in tests
-    feed.client.state.partialNext({ connected_user: undefined });
-    const user = generateUserResponse({ id: currentUserId });
-    const result1 = eventTriggeredByConnectedUser({ user });
-    const result2 = eventTriggeredByConnectedUser({});
-    expect(result1).toBe(false);
-    expect(result2).toBe(false);
-  });
-});