@stream-io/feeds-client 0.3.51 → 1.1.0

package/src/feed/feed.ts

@@ -13,7 +13,6 @@ import type {
   ThreadedCommentResponse,
   FollowRequest,
   QueryCommentsRequest,
-  ActivityAddedEvent,
   EnrichmentOptions,
 } from '../gen/models';
 import type { StreamResponse } from '../gen-imports';
@@ -39,9 +38,9 @@ import {
   handleBookmarkAdded,
   handleActivityDeleted,
   handleActivityRemovedFromFeed,
+  handleFeedDeleted,
   handleFeedUpdated,
   handleNotificationFeedUpdated,
-  handleActivityMarked,
   handleActivityReactionAdded,
   handleActivityReactionDeleted,
   handleActivityReactionUpdated,
@@ -51,15 +50,21 @@ import {
   addAggregatedActivitiesToState,
   updateNotificationStatus,
   handleStoriesFeedUpdated,
+  handleActivityPinned,
+  handleActivityUnpinned,
 } from './event-handlers';
 import { capitalize } from '../common/utils';
 import type {
   ActivityIdOrCommentId,
+  ConnectedUser,
   GetCommentsRepliesRequest,
   GetCommentsRequest,
   LoadingStates,
+  OnNewActivityCallback,
+  OnNewActivityResult,
   PagerResponseWithLoadingStates,
 } from '../types';
+import { activityFilter } from './activity-filter';
 import {
   checkHasAnotherPage,
   Constants,
@@ -143,12 +148,6 @@ export type FeedState = Omit<
    * `true` if the feed is receiving real-time updates via WebSocket
    */
   watch: boolean;
-
-  /**
-   * When a new activity is received from a WebSocket event by default it's added to the start of the list. You can change this to `end` to add it to the end of the list.
-   * Useful for story feeds.
-   */
-  addNewActivitiesTo: 'start' | 'end';
 };
 
 type EventHandlerByEventType = {
@@ -184,7 +183,7 @@ export class Feed extends FeedApi {
     'feeds.comment.deleted': handleCommentDeleted.bind(this),
     'feeds.comment.updated': handleCommentUpdated.bind(this),
     'feeds.feed.created': Feed.noop,
-    'feeds.feed.deleted': Feed.noop,
+    'feeds.feed.deleted': handleFeedDeleted.bind(this),
     'feeds.feed.updated': handleFeedUpdated.bind(this),
     'feeds.feed_group.changed': Feed.noop,
     'feeds.feed_group.deleted': Feed.noop,
@@ -207,9 +206,9 @@ export class Feed extends FeedApi {
     'feeds.poll.vote_casted': Feed.noop,
     'feeds.poll.vote_changed': Feed.noop,
     'feeds.poll.vote_removed': Feed.noop,
-    'feeds.activity.pinned': Feed.noop,
-    'feeds.activity.unpinned': Feed.noop,
-    'feeds.activity.marked': handleActivityMarked.bind(this),
+    'feeds.activity.pinned': handleActivityPinned.bind(this),
+    'feeds.activity.unpinned': handleActivityUnpinned.bind(this),
+    'feeds.activity.marked': Feed.noop,
     'moderation.custom_action': Feed.noop,
     'moderation.flagged': Feed.noop,
     'moderation.mark_reviewed': Feed.noop,
@@ -237,8 +236,7 @@ export class Feed extends FeedApi {
     id: string,
     data?: FeedResponse,
     watch = false,
-    addNewActivitiesTo: 'start' | 'end' = 'start',
-    public activityAddedEventFilter?: (event: ActivityAddedEvent) => boolean,
+    public onNewActivity?: OnNewActivityCallback,
   ) {
     super(client, groupId, id);
     this.state = new StateStore<FeedState>({
@@ -250,7 +248,6 @@ export class Feed extends FeedApi {
       is_loading_activities: false,
       comments_by_entity_id: {},
       watch,
-      addNewActivitiesTo,
     });
     this.client = client;
 
@@ -278,10 +275,6 @@ export class Feed extends FeedApi {
     return this.state.getLatestValue();
   }
 
-  set addNewActivitiesTo(value: 'start' | 'end') {
-    this.state.partialNext({ addNewActivitiesTo: value });
-  }
-
   hasActivity(activityId: string) {
     return this.indexedActivityIds.has(activityId);
   }
@@ -292,6 +285,31 @@ export class Feed extends FeedApi {
     );
   }
 
+  /**
+   * Resolves how to handle a new activity (WS or HTTP): ignore, add-to-start, or add-to-end.
+   * Uses onNewActivity if set; else default (current user + filter match) adds to start.
+   */
+  protected resolveNewActivityDecision(
+    activity: ActivityResponse,
+    currentUser: ConnectedUser | undefined,
+    _fromHttp: boolean,
+  ): OnNewActivityResult {
+    if (this.onNewActivity) {
+      return this.onNewActivity({ activity, currentUser });
+    }
+    if (!currentUser) return 'ignore';
+    if (activity.user?.id !== currentUser.id) return 'ignore';
+    if (
+      !activityFilter(
+        activity,
+        this.currentState.last_get_or_create_request_config,
+      )
+    ) {
+      return 'ignore';
+    }
+    return 'add-to-start';
+  }
+
   async synchronize() {
     const { last_get_or_create_request_config } = this.state.getLatestValue();
     if (last_get_or_create_request_config?.watch) {
@@ -346,6 +364,7 @@ export class Feed extends FeedApi {
           response.activities,
           currentActivities,
           'end',
+          { hasOwnFields: true, backfillOwnFields: false },
         );
 
         const aggregatedActivitiesResult = addAggregatedActivitiesToState(
@@ -416,7 +435,7 @@ export class Feed extends FeedApi {
         });
       }
 
-      this.newActivitiesAdded(response.activities);
+      this.activitiesAddedOrUpdated(response.activities);
 
       return response;
     } finally {
@@ -939,12 +958,44 @@ export class Feed extends FeedApi {
     });
   }
 
+  /**
+   * Applies a new activity to this feed's state (decision + add to activities).
+   * Used when the activity was added via this feed's addActivity or via client.addActivity.
+   */
+  protected addActivityFromHTTPResponse(activity: ActivityResponse): void {
+    const currentUser = this.client.state.getLatestValue().connected_user;
+    const decision = this.resolveNewActivityDecision(
+      activity,
+      currentUser,
+      true,
+    );
+    if (decision !== 'ignore') {
+      const position = decision === 'add-to-end' ? 'end' : 'start';
+      const currentActivities = this.currentState.activities;
+      const result = addActivitiesToState.bind(this)(
+        [activity],
+        currentActivities,
+        position,
+        {
+          hasOwnFields: activity.current_feed?.own_capabilities !== undefined,
+          backfillOwnFields: false,
+        },
+      );
+      if (result.changed) {
+        this.client.hydratePollCache([activity]);
+        this.state.partialNext({ activities: result.activities });
+      }
+    }
+  }
+
   async addActivity(request: Omit<ActivityRequest, 'feeds'>) {
     const response = await this.client.addActivity({
       ...request,
       feeds: [this.feed],
     });
 
+    this.addActivityFromHTTPResponse(response.activity);
+
     return response;
   }
 
@@ -983,11 +1034,12 @@ export class Feed extends FeedApi {
     this.eventDispatcher.dispatch(event);
   }
 
-  protected newActivitiesAdded(
+  protected activitiesAddedOrUpdated(
     activities: ActivityResponse[],
     options: {
-      fromWebSocket: boolean;
-    } = { fromWebSocket: false },
+      hasOwnFields: boolean;
+      backfillOwnFields: boolean;
+    } = { hasOwnFields: true, backfillOwnFields: true },
   ) {
     this.client.hydratePollCache(activities);
     this.getOrCreateFeeds(activities, options);
@@ -996,7 +1048,8 @@ export class Feed extends FeedApi {
   private getOrCreateFeeds(
     activities: ActivityResponse[],
     options: {
-      fromWebSocket: boolean;
+      hasOwnFields: boolean;
+      backfillOwnFields: boolean;
     },
   ) {
     const enrichmentOptions =
@@ -1018,7 +1071,7 @@ export class Feed extends FeedApi {
       const fieldsToUpdate: Array<
         'own_capabilities' | 'own_follows' | 'own_followings' | 'own_membership'
       > = [];
-      if (!options.fromWebSocket) {
+      if (options.hasOwnFields) {
         fieldsToUpdate.push('own_membership');
         if (!enrichmentOptions?.skip_own_capabilities) {
           fieldsToUpdate.push('own_capabilities');
@@ -1038,7 +1091,7 @@ export class Feed extends FeedApi {
           fieldsToUpdate,
         });
       });
-      if (options.fromWebSocket) {
+      if (!options.hasOwnFields && options.backfillOwnFields) {
         const uninitializedFeeds = newFeeds.filter((feedResponse) => {
           const feed = this.client.feed(feedResponse.group_id, feedResponse.id);
           // own_capabilities can only be undefined if we haven't fetched it yet

package/src/feeds-client/apply-new-activity-to-active-feeds.ts

@@ -0,0 +1,9 @@
+import type { Feed } from '../feed/feed';
+import type { ActivityResponse } from '../gen/models';
+
+export function applyNewActivityToActiveFeeds(
+  this: Feed,
+  activity: ActivityResponse,
+): void {
+  return this.addActivityFromHTTPResponse(activity);
+}