@stream-io/feeds-client 0.1.9 → 0.1.11

package/src/feed/event-handlers/feed-member/index.ts

@@ -0,0 +1,3 @@
+export * from './handle-feed-member-added';
+export * from './handle-feed-member-updated';
+export * from './handle-feed-member-removed';

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

@@ -0,0 +1,246 @@
+import { 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',
+          fid: 'user:feed-x',
+          created_by: {
+            ...mockUser,
+            id: 'user-x',
+          },
+          following_count: 1,
+        },
+        target_feed: {
+          ...mockFeed,
+          id: 'other-feed',
+          fid: '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]).toEqual(follow);
+      expect(result.data).toMatchObject(follow.source_feed);
+      expect(result.data.own_follows).toBeUndefined();
+      expect(result.data.following_count).toEqual(1);
+    });
+
+    it('should handle when someone follows this feed', () => {
+      const follow: FollowResponse = {
+        ...mockFollow,
+        source_feed: {
+          ...mockFeed,
+          id: 'other-feed',
+          fid: 'user:other-feed',
+          created_by: {
+            ...mockUser,
+            id: 'other-user',
+          },
+        },
+        target_feed: {
+          ...mockFeed,
+          id: 'feed-1',
+          fid: '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]).toEqual(follow);
+      expect(result.data).toMatchObject(follow.target_feed);
+      expect(result.data.own_follows).toBeUndefined();
+      expect(result.data.follower_count).toEqual(1);
+    });
+
+    it('should add to own_follows when connected user is the source', () => {
+      const follow: FollowResponse = {
+        ...mockFollow,
+        source_feed: {
+          ...mockFeed,
+          id: 'feed-1',
+          fid: 'user:feed-1',
+          created_by: { ...mockUser, id: 'user-1' },
+        },
+        target_feed: {
+          ...mockFeed,
+          id: 'feed-x',
+          fid: '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]).toEqual(follow);
+    });
+
+    it('should not update followers/following when they are undefined', () => {
+      const follow: FollowResponse = {
+        ...mockFollow,
+        source_feed: {
+          ...mockFeed,
+          id: 'other-feed',
+          fid: 'user:other-feed',
+          created_by: mockUser,
+        },
+        target_feed: {
+          ...mockFeed,
+          id: 'feed-1',
+          fid: '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',
+          fid: 'user:existing-feed',
+          created_by: mockUser,
+        },
+      };
+
+      const follow: FollowResponse = {
+        ...mockFollow,
+        source_feed: {
+          ...mockFeed,
+          id: 'other-feed',
+          fid: 'user:other-feed',
+          created_by: mockUser,
+        },
+        target_feed: {
+          ...mockFeed,
+          id: 'feed-1',
+          fid: '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]).toEqual(follow);
+      expect(result.data.followers?.[1]).toEqual(existingFollow);
+    });
+  });
+});

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

@@ -0,0 +1,93 @@
+import type { Feed, FeedState } from '../../../feed';
+import type { FollowResponse } from '../../../gen/models';
+import type {
+  EventPayload,
+  PartializeAllBut,
+  UpdateStateResult,
+} from '../../../types-internal';
+import {
+  getStateUpdateQueueId,
+  shouldUpdateState,
+} from '../../../utils';
+
+export const updateStateFollowCreated = (
+  follow: FollowResponse,
+  currentState: FeedState,
+  currentFeedId: string,
+  connectedUserId?: string,
+): UpdateStateResult<{ data: FeedState }> => {
+  // filter non-accepted follows (the way getOrCreate does by default)
+  if (follow.status !== 'accepted') {
+    return { changed: false, data: currentState };
+  }
+
+  let newState: FeedState = { ...currentState };
+
+  // this feed followed someone
+  if (follow.source_feed.fid === currentFeedId) {
+    newState = {
+      ...newState,
+      // Update FeedResponse fields, that has the new follower/following count
+      ...follow.source_feed,
+    };
+
+    // Only update if following array already exists
+    if (currentState.following !== undefined) {
+      newState.following = [follow, ...currentState.following];
+    }
+  } else if (
+    // someone followed this feed
+    follow.target_feed.fid === currentFeedId
+  ) {
+    const source = follow.source_feed;
+
+    newState = {
+      ...newState,
+      // Update FeedResponse fields, that has the new follower/following count
+      ...follow.target_feed,
+    };
+
+    if (source.created_by.id === connectedUserId) {
+      newState.own_follows = currentState.own_follows
+        ? currentState.own_follows.concat(follow)
+        : [follow];
+    }
+
+    // Only update if followers array already exists
+    if (currentState.followers !== undefined) {
+      newState.followers = [follow, ...currentState.followers];
+    }
+  }
+
+  return { changed: true, data: newState };
+};
+
+export function handleFollowCreated(
+  this: Feed,
+  eventOrResponse: PartializeAllBut<
+    EventPayload<'feeds.follow.created'>,
+    'follow'
+  >,
+) {
+  const follow = eventOrResponse.follow;
+
+  if (
+    !shouldUpdateState({
+      stateUpdateQueueId: getStateUpdateQueueId(follow, 'created'),
+      stateUpdateQueue: this.stateUpdateQueue,
+      watch: this.currentState.watch,
+    })
+  ) {
+    return;
+  }
+  const connectedUser = this.client.state.getLatestValue().connected_user;
+  const result = updateStateFollowCreated(
+    follow,
+    this.currentState,
+    this.fid,
+    connectedUser?.id,
+  );
+  if (result.changed) {
+    this.state.next(result.data);
+  }
+}

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

@@ -0,0 +1,264 @@
+import { 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',
+          fid: 'user:feed-1',
+          created_by: mockUser,
+        },
+        target_feed: {
+          ...mockFeed,
+          id: 'other-feed',
+          fid: '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',
+          fid: 'user:other-feed',
+          created_by: {
+            ...mockUser,
+            id: 'other-user',
+          },
+        },
+        target_feed: {
+          ...mockFeed,
+          id: 'feed-1',
+          fid: '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).toEqual(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',
+          fid: 'user:other-feed',
+          created_by: { ...mockUser, id: 'user-1' },
+        },
+        target_feed: {
+          ...mockFeed,
+          id: 'feed-1',
+          fid: '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',
+          fid: 'user:other-feed',
+          created_by: { ...mockUser, id: 'other-user' },
+        },
+        target_feed: {
+          ...mockFeed,
+          id: 'feed-1',
+          fid: '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',
+          fid: 'user:other-feed',
+          created_by: mockUser,
+        },
+        target_feed: {
+          ...mockFeed,
+          id: 'feed-1',
+          fid: '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',
+          fid: 'user:feed-1',
+          created_by: mockUser,
+        },
+        target_feed: {
+          ...mockFeed,
+          id: 'target-to-remove',
+          fid: 'user:target-to-remove',
+          created_by: mockUser,
+        },
+      };
+
+      const followToKeep: FollowResponse = {
+        ...mockFollow,
+        source_feed: {
+          ...mockFeed,
+          id: 'feed-1',
+          fid: 'user:feed-1',
+          created_by: mockUser,
+        },
+        target_feed: {
+          ...mockFeed,
+          id: 'target-to-keep',
+          fid: '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]).toEqual(followToKeep);
+    });
+  });
+});

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

@@ -0,0 +1,95 @@
+import type { Feed, FeedState } from '../../../feed';
+import type { FollowResponse } from '../../../gen/models';
+import type {
+  EventPayload,
+  PartializeAllBut,
+  UpdateStateResult,
+} from '../../../types-internal';
+
+import { getStateUpdateQueueId, shouldUpdateState } from '../../../utils';
+
+export const updateStateFollowDeleted = (
+  follow: FollowResponse,
+  currentState: FeedState,
+  currentFeedId: string,
+  connectedUserId?: string,
+): UpdateStateResult<{ data: FeedState }> => {
+  let newState: FeedState = { ...currentState };
+
+  // this feed unfollowed someone
+  if (follow.source_feed.fid === currentFeedId) {
+    newState = {
+      ...newState,
+      // Update FeedResponse fields, that has the new follower/following count
+      ...follow.source_feed,
+    };
+
+    // Only update if following array already exists
+    if (currentState.following !== undefined) {
+      newState.following = currentState.following.filter(
+        (followItem) => followItem.target_feed.fid !== follow.target_feed.fid,
+      );
+    }
+  } else if (
+    // someone unfollowed this feed
+    follow.target_feed.fid === currentFeedId
+  ) {
+    const source = follow.source_feed;
+
+    newState = {
+      ...newState,
+      // Update FeedResponse fields, that has the new follower/following count
+      ...follow.target_feed,
+    };
+
+    if (
+      source.created_by.id === connectedUserId &&
+      currentState.own_follows !== undefined
+    ) {
+      newState.own_follows = currentState.own_follows.filter(
+        (followItem) => followItem.source_feed.fid !== follow.source_feed.fid,
+      );
+    }
+
+    // Only update if followers array already exists
+    if (currentState.followers !== undefined) {
+      newState.followers = currentState.followers.filter(
+        (followItem) => followItem.source_feed.fid !== follow.source_feed.fid,
+      );
+    }
+  }
+
+  return { changed: true, data: newState };
+};
+
+export function handleFollowDeleted(
+  this: Feed,
+  eventOrResponse: PartializeAllBut<
+    EventPayload<'feeds.follow.deleted'>,
+    'follow'
+  >,
+) {
+  const follow = eventOrResponse.follow;
+
+  if (
+    !shouldUpdateState({
+      stateUpdateQueueId: getStateUpdateQueueId(follow, 'deleted'),
+      stateUpdateQueue: this.stateUpdateQueue,
+      watch: this.currentState.watch,
+    })
+  ) {
+    return;
+  }
+
+  const connectedUser = this.client.state.getLatestValue().connected_user;
+  const result = updateStateFollowDeleted(
+    follow,
+    this.currentState,
+    this.fid,
+    connectedUser?.id,
+  );
+
+  if (result.changed) {
+    this.state.next(result.data);
+  }
+}