@stream-io/feeds-client 0.1.10 → 0.2.0

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

@@ -0,0 +1,90 @@
+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.feed === 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.feed === 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.feed,
+    connectedUser?.id,
+  );
+  if (result.changed) {
+    this.state.next(result.data);
+  }
+}

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

@@ -0,0 +1,268 @@
+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',
+          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).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',
+          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]).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.feed === 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.feed !== follow.target_feed.feed,
+      );
+    }
+  } else if (
+    // someone unfollowed this feed
+    follow.target_feed.feed === 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.feed !== follow.source_feed.feed,
+      );
+    }
+
+    // Only update if followers array already exists
+    if (currentState.followers !== undefined) {
+      newState.followers = currentState.followers.filter(
+        (followItem) => followItem.source_feed.feed !== follow.source_feed.feed,
+      );
+    }
+  }
+
+  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.feed,
+    connectedUser?.id,
+  );
+
+  if (result.changed) {
+    this.state.next(result.data);
+  }
+}

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

@@ -0,0 +1,174 @@
+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 { FollowResponse } from '../../../gen/models';
+import { shouldUpdateState } from '../../../utils';
+
+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);
+  });
+
+  describe(`${shouldUpdateState.name} integration`, () => {
+    it(`skips update if ${shouldUpdateState.name} returns false`, () => {
+      // Prepare feed, set as watched
+      feed.state.partialNext({ watch: true });
+
+      const updatedFollow: FollowResponse = { ...follow, status: 'pending' };
+
+      // Call once to populate queue
+      handleFollowUpdated.call(feed, { follow: updatedFollow });
+
+      // Call again, should be skipped
+      const stateBefore = feed.currentState;
+      handleFollowUpdated.call(feed, {
+        follow: { ...updatedFollow, status: 'accepted' },
+      });
+
+      // State should not change
+      const stateAfter = feed.currentState;
+      expect(stateAfter).toEqual(stateBefore);
+    });
+
+    it('allows update again after clearing stateUpdateQueue', () => {
+      const updatedFollow: FollowResponse = { ...follow, status: 'pending' };
+
+      handleFollowUpdated.call(feed, { follow: updatedFollow });
+
+      // Clear the queue
+      (feed as any).stateUpdateQueue.clear();
+
+      // Now update should be allowed
+      handleFollowUpdated.call(feed, {
+        follow: { ...updatedFollow, status: 'accepted' },
+      });
+
+      const [updatedFollowAfter] = feed.currentState.following!;
+
+      expect(updatedFollowAfter).toMatchObject({
+        status: 'accepted',
+      });
+    });
+  });
+});

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

@@ -0,0 +1,85 @@
+import type { Feed, FeedState } from '../../../feed';
+import { getStateUpdateQueueId, shouldUpdateState } from '../../../utils';
+import { EventPayload, PartializeAllBut } from '../../../types-internal';
+
+export function handleFollowUpdated(
+  this: Feed,
+  eventOrResponse: PartializeAllBut<
+    EventPayload<'feeds.follow.updated'>,
+    'follow'
+  >,
+) {
+  const follow = eventOrResponse.follow;
+  const connectedUserId = this.client.state.getLatestValue().connected_user?.id;
+  const currentFeedId = this.feed;
+
+  if (
+    !shouldUpdateState({
+      stateUpdateQueueId: getStateUpdateQueueId(follow, 'updated'),
+      stateUpdateQueue: this.stateUpdateQueue,
+      watch: this.currentState.watch,
+    })
+  ) {
+    return;
+  }
+
+  this.state.next((currentState) => {
+    let newState: FeedState | undefined;
+
+    // this feed followed someone
+    if (follow.source_feed.feed === currentFeedId) {
+      newState ??= {
+        ...currentState,
+        // Update FeedResponse fields, that has the new follower/following count
+        ...follow.source_feed,
+      };
+
+      const index =
+        currentState.following?.findIndex(
+          (f) => f.target_feed.feed === follow.target_feed.feed,
+        ) ?? -1;
+
+      if (index >= 0) {
+        newState.following = [...newState.following!];
+        newState.following[index] = follow;
+      }
+    } else if (
+      // someone followed this feed
+      follow.target_feed.feed === currentFeedId
+    ) {
+      const source = follow.source_feed;
+
+      newState ??= {
+        ...currentState,
+        // Update FeedResponse fields, that has the new follower/following count
+        ...follow.target_feed,
+      };
+
+      if (
+        source.created_by.id === connectedUserId &&
+        currentState.own_follows
+      ) {
+        const index = currentState.own_follows.findIndex(
+          (f) => f.source_feed.feed === follow.source_feed.feed,
+        );
+
+        if (index >= 0) {
+          newState.own_follows = [...currentState.own_follows];
+          newState.own_follows[index] = follow;
+        }
+      }
+
+      const index =
+        currentState.followers?.findIndex(
+          (f) => f.source_feed.feed === follow.source_feed.feed,
+        ) ?? -1;
+
+      if (index >= 0) {
+        newState.followers = [...newState.followers!];
+        newState.followers[index] = follow;
+      }
+    }
+
+    return newState ?? currentState;
+  });
+}