@stream-io/feeds-client 0.2.9 → 0.2.11

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

@@ -10,8 +10,12 @@ import {
   generateFeedReactionResponse,
   generateFeedResponse,
   generateOwnUser,
+  generateUserResponseCommonFields,
   getHumanId,
-} from '../../../test-utils/response-generators';
+} from '../../../test-utils';
+import { EventPayload } from '../../../types-internal';
+import { shouldUpdateState } from '../../../utils';
+import { ActivityResponse } from '../../../gen/models';
 
 describe(handleActivityUpdated.name, () => {
   let feed: Feed;
@@ -112,4 +116,130 @@ describe(handleActivityUpdated.name, () => {
     const stateAfter = feed.currentState;
     expect(stateAfter).toBe(stateBefore);
   });
+
+  describe(`Activity updated ${shouldUpdateState.name} integration`, () => {
+    const activityId = 'reacted-activity';
+    const updatedText = 'updated-text';
+    let existingActivity: ActivityResponse;
+    let currentUserPayload: EventPayload<'feeds.activity.updated'>;
+
+    beforeEach(() => {
+      existingActivity = generateActivityResponse({
+        id: activityId,
+        text: 'original-text',
+      });
+      currentUserPayload = generateActivityUpdatedEvent({
+        activity: { ...existingActivity, text: updatedText },
+        user: generateUserResponseCommonFields({ id: currentUserId }),
+      });
+
+      feed.state.partialNext({ activities: [existingActivity] });
+      feed.state.partialNext({ watch: true });
+    });
+
+    it(`skips update if ${shouldUpdateState.name} returns false`, () => {
+      // 1. HTTP and then WS
+
+      handleActivityUpdated.call(feed, currentUserPayload, false);
+
+      let stateBefore = feed.currentState;
+
+      handleActivityUpdated.call(feed, currentUserPayload);
+
+      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 the HTTP
+
+      handleActivityUpdated.call(feed, currentUserPayload);
+
+      stateBefore = feed.currentState;
+
+      handleActivityUpdated.call(feed, currentUserPayload, false);
+
+      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', () => {
+      handleActivityUpdated.call(feed, currentUserPayload);
+
+      expect(feed.currentState.activities?.[0]).toMatchObject({
+        ...existingActivity,
+        text: updatedText,
+      });
+
+      // Clear the queue
+      (feed as any).stateUpdateQueue.clear();
+
+      // Now update should be allowed from another WS event
+      handleActivityUpdated.call(feed, {
+        ...currentUserPayload,
+        activity: {
+          ...currentUserPayload.activity,
+          text: 'updated-again-text',
+        },
+      });
+
+      expect(feed.currentState.activities?.[0]).toMatchObject({
+        ...existingActivity,
+        text: 'updated-again-text',
+      });
+    });
+
+    it('allows update again from HTTP response after clearing the stateUpdateQueue', () => {
+      handleActivityUpdated.call(feed, currentUserPayload, false);
+
+      expect(feed.currentState.activities?.[0]).toMatchObject({
+        ...existingActivity,
+        text: updatedText,
+      });
+
+      // Clear the queue
+      (feed as any).stateUpdateQueue.clear();
+
+      // Now update should be allowed from another WS event
+      handleActivityUpdated.call(
+        feed,
+        {
+          ...currentUserPayload,
+          activity: {
+            ...currentUserPayload.activity,
+            text: 'updated-again-text',
+          },
+        },
+        false,
+      );
+
+      expect(feed.currentState.activities?.[0]).toMatchObject({
+        ...existingActivity,
+        text: 'updated-again-text',
+      });
+    });
+
+    it('should not insert anything into the stateUpdateQueue if the connected_user did not trigger the reaction', () => {
+      const otherUserPayload = {
+        ...currentUserPayload,
+        user: generateUserResponseCommonFields({ id: getHumanId() }),
+      };
+
+      handleActivityUpdated.call(feed, otherUserPayload);
+
+      expect((feed as any).stateUpdateQueue).toEqual(new Set());
+
+      handleActivityUpdated.call(feed, otherUserPayload);
+
+      expect((feed as any).stateUpdateQueue).toEqual(new Set());
+      expect(feed.currentState.activities?.[0]).toMatchObject({
+        ...existingActivity,
+        text: updatedText,
+      });
+    });
+  });
 });

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

@@ -1,18 +1,24 @@
 import { Feed } from '../../../feed';
+import { ActivityPinResponse, ActivityResponse } from '../../../gen/models';
+import { EventPayload, PartializeAllBut } from '../../../types-internal';
 import {
-  ActivityPinResponse,
-  ActivityResponse,
-  ActivityUpdatedEvent,
-} from '../../../gen/models';
-import { EventPayload } from '../../../types-internal';
-import { updateEntityInArray } from '../../../utils';
+  getStateUpdateQueueId,
+  shouldUpdateState,
+  updateEntityInArray,
+} from '../../../utils';
+import { eventTriggeredByConnectedUser } from '../../../utils/event-triggered-by-connected-user';
+
+export type ActivityUpdatedPayload = PartializeAllBut<
+  EventPayload<'feeds.activity.updated'>,
+  'activity'
+>;
 
 const sharedUpdateActivity = ({
   currentActivity,
   event,
 }: {
   currentActivity: ActivityResponse;
-  event: ActivityUpdatedEvent;
+  event: ActivityUpdatedPayload;
 }) => {
   return {
     ...event.activity,
@@ -22,7 +28,7 @@ const sharedUpdateActivity = ({
 };
 
 export const updateActivityInState = (
-  event: ActivityUpdatedEvent,
+  event: ActivityUpdatedPayload,
   activities: ActivityResponse[] | undefined,
 ) =>
   updateEntityInArray({
@@ -36,7 +42,7 @@ export const updateActivityInState = (
   });
 
 export const updatePinnedActivityInState = (
-  event: ActivityUpdatedEvent,
+  event: ActivityUpdatedPayload,
   pinnedActivities: ActivityPinResponse[] | undefined,
 ) =>
   updateEntityInArray({
@@ -62,23 +68,40 @@ export const updatePinnedActivityInState = (
 
 export function handleActivityUpdated(
   this: Feed,
-  event: EventPayload<'feeds.activity.updated'>,
+  payload: ActivityUpdatedPayload,
+  fromWs?: boolean,
 ) {
+  if (
+    !shouldUpdateState({
+      stateUpdateQueueId: getStateUpdateQueueId(payload, 'activity-updated'),
+      stateUpdateQueue: this.stateUpdateQueue,
+      watch: this.currentState.watch,
+      fromWs,
+      isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(
+        this,
+        payload,
+      ),
+    })
+  ) {
+    return;
+  }
   const {
     activities: currentActivities,
     pinned_activities: currentPinnedActivities,
   } = this.currentState;
 
   const [result1, result2] = [
-    updateActivityInState(event, currentActivities),
-    updatePinnedActivityInState(event, currentPinnedActivities),
+    this.hasActivity(payload.activity.id)
+      ? updateActivityInState(payload, currentActivities)
+      : undefined,
+    updatePinnedActivityInState(payload, currentPinnedActivities),
   ];
 
-  if (result1.changed || result2.changed) {
-    this.client.hydratePollCache([event.activity]);
+  if (result1?.changed || result2.changed) {
+    this.client.hydratePollCache([payload.activity]);
 
     this.state.partialNext({
-      activities: result1.entities,
+      activities: result1?.changed ? result1.entities : currentActivities,
       pinned_activities: result2.entities,
     });
   }

package/src/feed/event-handlers/comment/handle-comment-added.test.ts

@@ -8,7 +8,11 @@ import {
   getHumanId,
   generateCommentAddedEvent,
   generateCommentResponse,
-} from '../../../test-utils/response-generators';
+  generateUserResponseCommonFields,
+} from '../../../test-utils';
+import { CommentResponse, UserResponseCommonFields } from '../../../gen/models';
+import { EventPayload } from '../../../types-internal';
+import { shouldUpdateState } from '../../../utils';
 
 describe(handleCommentAdded.name, () => {
   let feed: Feed;
@@ -64,9 +68,9 @@ describe(handleCommentAdded.name, () => {
     expect(stateAfter.comments_by_entity_id[activityId]!.comments).toHaveLength(
       2,
     );
-    expect(
-      stateAfter.comments_by_entity_id[activityId]!.comments!.at(-1),
-    ).toBe(event.comment);
+    expect(stateAfter.comments_by_entity_id[activityId]!.comments!.at(-1)).toBe(
+      event.comment,
+    );
   });
 
   it('prepends a new comment when pagination.sort is "last"', () => {
@@ -97,9 +101,9 @@ describe(handleCommentAdded.name, () => {
     expect(stateAfter.comments_by_entity_id[activityId]!.comments).toHaveLength(
       2,
     );
-    expect(
-      stateAfter.comments_by_entity_id[activityId]!.comments!.at(0),
-    ).toBe(event.comment);
+    expect(stateAfter.comments_by_entity_id[activityId]!.comments!.at(0)).toBe(
+      event.comment,
+    );
   });
 
   it('stores the comment in the correct parent entity state (prefers parent_id)', () => {
@@ -144,4 +148,124 @@ describe(handleCommentAdded.name, () => {
     const stateAfter = feed.currentState;
     expect(stateAfter).toBe(stateBefore);
   });
+
+  describe(`Comment added ${shouldUpdateState.name} integration`, () => {
+    let currentUserPayload: EventPayload<'feeds.comment.added'>;
+    let existingComment: CommentResponse;
+    let newComment: CommentResponse;
+    let commentId: string;
+
+    beforeEach(() => {
+      commentId = `comment-${getHumanId()}`;
+      existingComment = generateCommentResponse({
+        id: commentId,
+        object_id: activityId,
+      });
+      newComment = generateCommentResponse({
+        id: `comment-${getHumanId()}`,
+        object_id: activityId,
+      });
+
+      currentUserPayload = generateCommentAddedEvent({
+        comment: newComment,
+        user: client.state.getLatestValue()
+          .connected_user as UserResponseCommonFields,
+      });
+
+      feed.state.partialNext({
+        comments_by_entity_id: {
+          [activityId]: {
+            comments: [existingComment],
+            pagination: { sort: 'first' },
+          },
+        },
+      });
+      feed.state.partialNext({ watch: true });
+    });
+
+    it(`skips update if ${shouldUpdateState.name} returns false`, () => {
+      // 1. HTTP and then WS
+
+      handleCommentAdded.call(feed, currentUserPayload, false);
+
+      let stateBefore = feed.currentState;
+
+      handleCommentAdded.call(feed, currentUserPayload);
+
+      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 the HTTP
+
+      handleCommentAdded.call(feed, currentUserPayload);
+
+      stateBefore = feed.currentState;
+
+      handleCommentAdded.call(feed, currentUserPayload, false);
+
+      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', () => {
+      handleCommentAdded.call(feed, currentUserPayload);
+
+      // Clear the queue
+      (feed as any).stateUpdateQueue.clear();
+
+      // Now update should be allowed from another WS event
+      handleCommentAdded.call(feed, currentUserPayload);
+
+      const comments =
+        feed.currentState.comments_by_entity_id[activityId]?.comments;
+      const [latestComment] = (comments ?? []).toReversed();
+
+      expect(comments?.length).toEqual(3);
+      expect(latestComment).toMatchObject(newComment);
+    });
+
+    it('allows update again from HTTP response after clearing the stateUpdateQueue', () => {
+      handleCommentAdded.call(feed, currentUserPayload, false);
+
+      // Clear the queue
+      (feed as any).stateUpdateQueue.clear();
+
+      // Now update should be allowed from another HTTP response
+      handleCommentAdded.call(feed, currentUserPayload, false);
+
+      const comments =
+        feed.currentState.comments_by_entity_id[activityId]?.comments;
+      const [latestComment] = (comments ?? []).toReversed();
+
+      expect(comments?.length).toEqual(3);
+      expect(latestComment).toMatchObject(newComment);
+    });
+
+    it('should not insert anything into the stateUpdateQueue if the connected_user did not trigger the comment reaction deletion', () => {
+      const otherUserPayload = generateCommentAddedEvent({
+        comment: newComment,
+        user: generateUserResponseCommonFields({ id: getHumanId() }),
+      });
+
+      handleCommentAdded.call(feed, otherUserPayload);
+
+      expect((feed as any).stateUpdateQueue).toEqual(new Set());
+
+      handleCommentAdded.call(feed, otherUserPayload);
+
+      const comments =
+        feed.currentState.comments_by_entity_id[activityId]?.comments;
+      const [latestComment] = (comments ?? []).toReversed();
+
+      expect((feed as any).stateUpdateQueue).toEqual(new Set());
+      expect(comments?.length).toEqual(3);
+      expect(latestComment).toMatchObject(newComment);
+    });
+  });
 });

package/src/feed/event-handlers/comment/handle-comment-added.ts

@@ -1,13 +1,33 @@
-import type { Feed } from '../../../feed';
-import type { EventPayload } from '../../../types-internal';
+import type { Feed } from '../../feed';
+import type { EventPayload, PartializeAllBut } from '../../../types-internal';
+import { getStateUpdateQueueId, shouldUpdateState } from '../../../utils';
+import { eventTriggeredByConnectedUser } from '../../../utils/event-triggered-by-connected-user';
+
+export type CommentAddedPayload = PartializeAllBut<
+  EventPayload<'feeds.comment.added'>,
+  'comment'
+>;
 
 export function handleCommentAdded(
   this: Feed,
-  event: EventPayload<'feeds.comment.added'>,
+  payload: CommentAddedPayload,
+  fromWs?: boolean,
 ) {
-  const { comment } = event;
+  const { comment } = payload;
   const entityId = comment.parent_id ?? comment.object_id;
 
+  if (
+    !shouldUpdateState({
+      stateUpdateQueueId: getStateUpdateQueueId(payload, 'comment-created'),
+      stateUpdateQueue: this.stateUpdateQueue,
+      watch: this.currentState.watch,
+      fromWs,
+      isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(this, payload),
+    })
+  ) {
+    return;
+  }
+
   this.state.next((currentState) => {
     const entityState = currentState.comments_by_entity_id[entityId];
 

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

@@ -6,9 +6,12 @@ import {
   generateCommentDeletedEvent,
   generateCommentResponse,
   generateFeedResponse,
-  generateOwnUser,
+  generateOwnUser, generateUserResponseCommonFields,
   getHumanId,
-} from '../../../test-utils/response-generators';
+} from '../../../test-utils';
+import { CommentResponse, UserResponseCommonFields } from '../../../gen/models';
+import { shouldUpdateState } from '../../../utils';
+import { EventPayload } from '../../../types-internal';
 
 describe(handleCommentDeleted.name, () => {
   let feed: Feed;
@@ -130,4 +133,123 @@ describe(handleCommentDeleted.name, () => {
 
     expect(stateAfter).toBe(stateBefore);
   });
+
+  describe(`Comment deleted ${shouldUpdateState.name} integration`, () => {
+    let currentUserPayload: EventPayload<'feeds.comment.deleted'>;
+    let existingComment: CommentResponse;
+    let commentToDelete: CommentResponse;
+    let commentId: string;
+
+    beforeEach(() => {
+      commentId = `comment-${getHumanId()}`;
+      existingComment = generateCommentResponse({
+        id: commentId,
+        object_id: activityId,
+      });
+      commentToDelete = generateCommentResponse({
+        id: `comment-${getHumanId()}`,
+        object_id: activityId,
+      })
+
+      currentUserPayload = generateCommentDeletedEvent({
+        comment: commentToDelete,
+        user: client.state.getLatestValue().connected_user as UserResponseCommonFields,
+      });
+
+      feed.state.partialNext({
+        comments_by_entity_id: {
+          [activityId]: {
+            comments: [existingComment, commentToDelete],
+            pagination: { sort: 'first' },
+          },
+        },
+      });
+      feed.state.partialNext({ watch: true });
+    });
+
+    it(`skips update if ${shouldUpdateState.name} returns false`, () => {
+      // 1. HTTP and then WS
+
+      handleCommentDeleted.call(feed, currentUserPayload, false);
+
+      let stateBefore = feed.currentState;
+
+      handleCommentDeleted.call(feed, currentUserPayload);
+
+      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 the HTTP
+
+      handleCommentDeleted.call(feed, currentUserPayload);
+
+      stateBefore = feed.currentState;
+
+      handleCommentDeleted.call(feed, currentUserPayload, false);
+
+      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', () => {
+      handleCommentDeleted.call(feed, currentUserPayload);
+
+      // Clear the queue
+      (feed as any).stateUpdateQueue.clear();
+
+      // Now update should be allowed from another WS event
+      handleCommentDeleted.call(feed, currentUserPayload);
+
+      const comments =
+        feed.currentState.comments_by_entity_id[activityId]?.comments;
+      const [latestComment] = (comments ?? []).toReversed();
+
+      expect(comments?.length).toEqual(1);
+      expect(latestComment).toBe(existingComment);
+    });
+
+    it('allows update again from HTTP response after clearing the stateUpdateQueue', () => {
+      handleCommentDeleted.call(feed, currentUserPayload, false);
+
+      // Clear the queue
+      (feed as any).stateUpdateQueue.clear();
+
+      // Now update should be allowed from another HTTP response
+      handleCommentDeleted.call(feed, currentUserPayload, false);
+
+      const comments =
+        feed.currentState.comments_by_entity_id[activityId]?.comments;
+      const [latestComment] = (comments ?? []).toReversed();
+
+      expect(comments?.length).toEqual(1);
+      expect(latestComment).toBe(existingComment);
+    });
+
+    it('should not insert anything into the stateUpdateQueue if the connected_user did not trigger the comment reaction deletion', () => {
+      const otherUserPayload = generateCommentDeletedEvent({
+        comment: commentToDelete,
+        user: generateUserResponseCommonFields({ id: getHumanId() })
+      });
+
+      handleCommentDeleted.call(feed, otherUserPayload);
+
+      expect((feed as any).stateUpdateQueue).toEqual(new Set());
+
+      handleCommentDeleted.call(feed, otherUserPayload);
+
+      const comments =
+        feed.currentState.comments_by_entity_id[activityId]?.comments;
+      const [latestComment] = (comments ?? []).toReversed();
+
+      expect((feed as any).stateUpdateQueue).toEqual(new Set());
+      expect(comments?.length).toEqual(1);
+      expect(latestComment).toBe(existingComment);
+    });
+  });
 });

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

@@ -1,12 +1,38 @@
-import { Feed } from '../../../feed';
-import { EventPayload } from '../../../types-internal';
+import { Feed } from '../../feed';
+import { EventPayload, type PartializeAllBut } from '../../../types-internal';
+import { getStateUpdateQueueId, shouldUpdateState } from '../../../utils';
+import {
+  eventTriggeredByConnectedUser
+} from '../../../utils/event-triggered-by-connected-user';
+
+export type CommentDeletedPayload = PartializeAllBut<
+  EventPayload<'feeds.comment.deleted'>,
+  'comment'
+>;
 
 export function handleCommentDeleted(
   this: Feed,
-  { comment }: EventPayload<'feeds.comment.deleted'>,
+  payload: CommentDeletedPayload,
+  fromWs?: boolean,
 ) {
+  const { comment } = payload;
   const entityId = comment.parent_id ?? comment.object_id;
 
+  if (
+    !shouldUpdateState({
+      stateUpdateQueueId: getStateUpdateQueueId(
+        payload,
+        'comment-deleted',
+      ),
+      stateUpdateQueue: this.stateUpdateQueue,
+      watch: this.currentState.watch,
+      fromWs,
+      isTriggeredByConnectedUser: eventTriggeredByConnectedUser.call(this, payload),
+    })
+  ) {
+    return;
+  }
+
   this.state.next((currentState) => {
     let newCommentsByEntityId:
       | typeof currentState.comments_by_entity_id