@stream-io/feeds-client 0.2.7 → 0.2.9

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

@@ -0,0 +1,219 @@
+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.ts

@@ -1,4 +1,4 @@
-import type { Feed, FeedState } from '../../../feed';
+import type { Feed, FeedState } from '../../feed';
 import type { FollowResponse } from '../../../gen/models';
 import type {
   EventPayload,
@@ -65,14 +65,19 @@ export function handleFollowCreated(
     EventPayload<'feeds.follow.created'>,
     'follow'
   >,
+  fromWs?: boolean,
 ) {
   const follow = eventOrResponse.follow;
 
   if (
     !shouldUpdateState({
-      stateUpdateQueueId: getStateUpdateQueueId(follow, 'created'),
+      stateUpdateQueueId: getStateUpdateQueueId(follow, 'follow-created'),
       stateUpdateQueue: this.stateUpdateQueue,
       watch: this.currentState.watch,
+      fromWs,
+      isTriggeredByConnectedUser:
+        this.client.state.getLatestValue().connected_user?.id ===
+        follow.source_feed.created_by.id,
     })
   ) {
     return;

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

@@ -68,6 +68,7 @@ export function handleFollowDeleted(
     EventPayload<'feeds.follow.deleted'>,
     'follow'
   >,
+  fromWs?: boolean,
 ) {
   const follow = eventOrResponse.follow;
 
@@ -76,6 +77,10 @@ export function handleFollowDeleted(
       stateUpdateQueueId: getStateUpdateQueueId(follow, 'deleted'),
       stateUpdateQueue: this.stateUpdateQueue,
       watch: this.currentState.watch,
+      fromWs,
+      isTriggeredByConnectedUser:
+        this.client.state.getLatestValue().connected_user?.id ===
+        follow.source_feed.created_by.id,
     })
   ) {
     return;

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

@@ -9,7 +9,6 @@ import {
   generateOwnUser,
 } from '../../../test-utils/response-generators';
 import { FollowResponse } from '../../../gen/models';
-import { shouldUpdateState } from '../../../utils';
 
 describe(handleFollowUpdated.name, () => {
   let feed: Feed;
@@ -129,46 +128,4 @@ describe(handleFollowUpdated.name, () => {
     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).toBe(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

@@ -1,4 +1,4 @@
-import type { Feed, FeedState } from '../../../feed';
+import type { Feed, FeedState } from '../../feed';
 import { getStateUpdateQueueId, shouldUpdateState } from '../../../utils';
 import { EventPayload, PartializeAllBut } from '../../../types-internal';
 
@@ -8,6 +8,7 @@ export function handleFollowUpdated(
     EventPayload<'feeds.follow.updated'>,
     'follow'
   >,
+  fromWs?: boolean,
 ) {
   const follow = eventOrResponse.follow;
   const connectedUserId = this.client.state.getLatestValue().connected_user?.id;
@@ -15,9 +16,13 @@ export function handleFollowUpdated(
 
   if (
     !shouldUpdateState({
-      stateUpdateQueueId: getStateUpdateQueueId(follow, 'updated'),
+      stateUpdateQueueId: getStateUpdateQueueId(follow, 'follow-updated'),
       stateUpdateQueue: this.stateUpdateQueue,
       watch: this.currentState.watch,
+      fromWs,
+      isTriggeredByConnectedUser:
+        this.client.state.getLatestValue().connected_user?.id ===
+        follow.source_feed.created_by.id,
     })
   ) {
     return;

package/src/feed/feed.test.ts

@@ -0,0 +1,90 @@
+import { beforeEach, describe, expect, it } from 'vitest';
+import { FeedsClient } from '../feeds-client';
+import { Feed } from './feed';
+import { 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/feed/feed.ts

@@ -15,7 +15,7 @@ import {
   QueryCommentsRequest,
 } from '../gen/models';
 import { StreamResponse } from '../gen-imports';
-import { StateStore } from '../common/StateStore';
+import { StateStore } from '@stream-io/state-store';
 import { EventDispatcher } from '../common/EventDispatcher';
 import { FeedApi } from '../gen/feeds/FeedApi';
 import { FeedsClient } from '../feeds-client';
@@ -38,11 +38,11 @@ import {
   handleBookmarkAdded,
   handleActivityDeleted,
   handleActivityRemovedFromFeed,
-  handleActivityReactionDeleted,
-  handleActivityReactionAdded,
   handleFeedUpdated,
   handleNotificationFeedUpdated,
   handleActivityMarked,
+  handleActivityReactionAdded,
+  handleActivityReactionDeleted,
 } from './event-handlers';
 import { capitalize } from '../common/utils';
 import type {
@@ -139,6 +139,7 @@ type EventHandlerByEventType = {
 export class Feed extends FeedApi {
   readonly state: StateStore<FeedState>;
   private static readonly noop = () => {};
+  protected indexedActivityIds: Set<string> = new Set();
   protected readonly stateUpdateQueue: Set<string> = new Set();
 
   private readonly eventHandlers: EventHandlerByEventType = {
@@ -217,6 +218,19 @@ export class Feed extends FeedApi {
       watch,
     });
     this.client = client;
+
+    this.state.subscribeWithSelector(
+      (nextState) => ({ activities: nextState.activities }),
+      (nextState) => {
+        const { activities: nextActivities = [] } = nextState;
+
+        if (this.indexedActivityIds.size !== nextActivities?.length) {
+          this.indexedActivityIds = new Set(
+            nextActivities.map((activity) => activity.id),
+          );
+        }
+      },
+    );
   }
 
   protected readonly client: FeedsClient;
@@ -229,6 +243,10 @@ export class Feed extends FeedApi {
     return this.state.getLatestValue();
   }
 
+  hasActivity(activityId: string) {
+    return this.indexedActivityIds.has(activityId);
+  }
+
   async synchronize() {
     const { last_get_or_create_request_config } = this.state.getLatestValue();
     if (last_get_or_create_request_config?.watch) {
@@ -254,7 +272,7 @@ export class Feed extends FeedApi {
       if (request?.next) {
         const { activities: currentActivities = [] } = this.currentState;
 
-        const result = addActivitiesToState(
+        const result = addActivitiesToState.bind(this)(
           response.activities,
           currentActivities,
           'end',
@@ -282,6 +300,9 @@ export class Feed extends FeedApi {
         delete responseCopy.metadata;
         delete responseCopy.duration;
 
+        // recreate the caches so that they are updated on the next state update
+        this.indexedActivityIds = new Set();
+
         // TODO: lazy-load comments from activities when comment_sort and comment_pagination are supported
 
         this.state.next((currentState) => {

package/src/feeds-client/feeds-client.ts

@@ -1,6 +1,8 @@
 import { FeedsApi } from '../gen/feeds/FeedsApi';
 import {
   ActivityResponse,
+  AddReactionRequest,
+  DeleteActivityReactionResponse,
   FeedResponse,
   FileUploadRequest,
   FollowBatchRequest,
@@ -16,7 +18,7 @@ import {
   WSEvent,
 } from '../gen/models';
 import { FeedsEvent, StreamFile, TokenOrProvider } from '../types';
-import { StateStore } from '../common/StateStore';
+import { StateStore } from '@stream-io/state-store';
 import { TokenManager } from '../common/TokenManager';
 import { ConnectionIdManager } from '../common/ConnectionIdManager';
 import { StableWSConnection } from '../common/real-time/StableWSConnection';
@@ -37,6 +39,8 @@ import { ModerationClient } from '../moderation-client';
 import { StreamPoll } from '../common/Poll';
 import {
   Feed,
+  handleActivityReactionAdded,
+  handleActivityReactionDeleted,
   handleFeedUpdated,
   handleFollowCreated,
   handleFollowDeleted,
@@ -49,6 +53,7 @@ import {
   SyncFailure,
   UnhandledErrorType,
 } from '../common/real-time/event-models';
+import { configureLoggers } from '../utils/logger';
 
 export type FeedsClientState = {
   connected_user: OwnUser | undefined;
@@ -93,6 +98,9 @@ export class FeedsClient extends FeedsApi {
     this.tokenManager = tokenManager;
     this.connectionIdManager = connectionIdManager;
     this.polls_by_id = new Map();
+
+    configureLoggers(options?.configure_loggers_options);
+
     this.on('all', (event) => {
       const fid = event.fid;
 
@@ -323,6 +331,29 @@ export class FeedsClient extends FeedsApi {
     });
   };
 
+  addReaction = async (
+    request: AddReactionRequest & {
+      activity_id: string;
+    },
+  ) => {
+    const response = await super.addReaction(request);
+    for (const feed of Object.values(this.activeFeeds)) {
+      handleActivityReactionAdded.bind(feed)(response, false);
+    }
+    return response;
+  };
+
+  deleteActivityReaction = async (request: {
+    activity_id: string;
+    type: string;
+  }): Promise<StreamResponse<DeleteActivityReactionResponse>> => {
+    const response = await super.deleteActivityReaction(request);
+    for (const feed of Object.values(this.activeFeeds)) {
+      handleActivityReactionDeleted.bind(feed)(response, false);
+    }
+    return response;
+  };
+
   queryPollAnswers = async (
     request: QueryPollVotesRequest & { poll_id: string; user_id?: string },
   ): Promise<StreamResponse<PollVotesResponse>> => {
@@ -413,7 +444,7 @@ export class FeedsClient extends FeedsApi {
     ].forEach((fid) => {
       const feed = this.activeFeeds[fid];
       if (feed) {
-        handleFollowUpdated.bind(feed)(response);
+        handleFollowUpdated.bind(feed)(response, false);
       }
     });
 
@@ -430,7 +461,7 @@ export class FeedsClient extends FeedsApi {
     ].forEach((fid) => {
       const feed = this.activeFeeds[fid];
       if (feed) {
-        handleFollowCreated.bind(feed)(response);
+        handleFollowCreated.bind(feed)(response, false);
       }
     });
 
@@ -456,7 +487,7 @@ export class FeedsClient extends FeedsApi {
     [request.source, request.target].forEach((fid) => {
       const feed = this.activeFeeds[fid];
       if (feed) {
-        handleFollowDeleted.bind(feed)(response);
+        handleFollowDeleted.bind(feed)(response, false);
       }
     });
 

package/src/gen/feeds/FeedsApi.ts

@@ -580,6 +580,7 @@ export class FeedsApi {
     const body = {
       type: request?.type,
       create_notification_activity: request?.create_notification_activity,
+      enforce_unique: request?.enforce_unique,
       skip_push: request?.skip_push,
       custom: request?.custom,
     };
@@ -1037,6 +1038,7 @@ export class FeedsApi {
     const body = {
       type: request?.type,
       create_notification_activity: request?.create_notification_activity,
+      enforce_unique: request?.enforce_unique,
       skip_push: request?.skip_push,
       custom: request?.custom,
     };

package/src/gen/model-decoders/decoders.ts

@@ -481,6 +481,8 @@ decoders.Channel = (input?: Record<string, any>) => {
 
     created_by: { type: 'User', isSingle: true },
 
+    members_lookup: { type: 'ChannelMemberLookup', isSingle: false },
+
     truncated_by: { type: 'User', isSingle: true },
   };
   return decode(typeMappings, input);
@@ -529,6 +531,17 @@ decoders.ChannelMember = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.ChannelMemberLookup = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    archived_at: { type: 'DatetimeType', isSingle: true },
+
+    ban_expires: { type: 'DatetimeType', isSingle: true },
+
+    pinned_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.ChannelMute = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -734,6 +747,15 @@ decoders.DeleteCommentReactionResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.DeleteCommentResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    activity: { type: 'ActivityResponse', isSingle: true },
+
+    comment: { type: 'CommentResponse', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.Device = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },