@stream-io/feeds-client 0.3.51 → 1.0.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';
@@ -55,11 +54,15 @@ import {
 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 +146,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 = {
@@ -237,8 +234,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 +246,6 @@ export class Feed extends FeedApi {
       is_loading_activities: false,
       comments_by_entity_id: {},
       watch,
-      addNewActivitiesTo,
     });
     this.client = client;
 
@@ -278,10 +273,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 +283,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 +362,7 @@ export class Feed extends FeedApi {
           response.activities,
           currentActivities,
           'end',
+          { hasOwnFields: true, backfillOwnFields: false },
         );
 
         const aggregatedActivitiesResult = addAggregatedActivitiesToState(
@@ -416,7 +433,7 @@ export class Feed extends FeedApi {
         });
       }
 
-      this.newActivitiesAdded(response.activities);
+      this.activitiesAddedOrUpdated(response.activities);
 
       return response;
     } finally {
@@ -939,12 +956,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 +1032,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 +1046,8 @@ export class Feed extends FeedApi {
   private getOrCreateFeeds(
     activities: ActivityResponse[],
     options: {
-      fromWebSocket: boolean;
+      hasOwnFields: boolean;
+      backfillOwnFields: boolean;
     },
   ) {
     const enrichmentOptions =
@@ -1018,7 +1069,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 +1089,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);
+}

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

@@ -1,7 +1,8 @@
 import { FeedsApi } from '../gen/feeds/FeedsApi';
 import type {
-  ActivityAddedEvent,
   ActivityResponse,
+  AddActivityRequest,
+  AddActivityResponse,
   AddCommentReactionRequest,
   AddCommentReactionResponse,
   AddCommentRequest,
@@ -41,6 +42,7 @@ import type {
 import type {
   ConnectedUser,
   FeedsEvent,
+  OnNewActivityCallback,
   StreamFile,
   TokenOrProvider,
 } from '../types';
@@ -82,6 +84,7 @@ import {
   handleWatchStarted,
   handleWatchStopped,
 } from '../feed';
+import { applyNewActivityToActiveFeeds } from './apply-new-activity-to-active-feeds';
 import { handleUserUpdated } from './event-handlers';
 import {
   type SyncFailure,
@@ -614,6 +617,19 @@ export class FeedsClient extends FeedsApi {
     return response;
   };
 
+  async addActivity(
+    request: AddActivityRequest,
+  ): Promise<StreamResponse<AddActivityResponse>> {
+    const response = await super.addActivity(request);
+    request.feeds.forEach((fid) => {
+      const feed = this.activeFeeds[fid];
+      if (feed) {
+        applyNewActivityToActiveFeeds.call(feed, response.activity);
+      }
+    });
+    return response;
+  }
+
   addActivityReaction = async (
     request: AddReactionRequest & {
       activity_id: string;
@@ -737,16 +753,14 @@ export class FeedsClient extends FeedsApi {
    * @param groupId for example `user`, `notification` or id of a custom feed group
    * @param id
    * @param options
-   * @param options.addNewActivitiesTo - 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.
-   * @param options.activityAddedEventFilter - a callback that is called when a new activity is received from a WebSocket event. You can use this to prevent the activity from being added to the feed. Useful for feed filtering, or if you don't want new activities to be added to the feed.
+   * @param options.onNewActivity - callback to control how new activities (WS or addActivity response) are added: 'add-to-start', 'add-to-end', or 'ignore'.
    * @returns
    */
   feed = (
     groupId: string,
     id: string,
     options?: {
-      addNewActivitiesTo?: 'start' | 'end';
-      activityAddedEventFilter?: (event: ActivityAddedEvent) => boolean;
+      onNewActivity?: OnNewActivityCallback;
     },
   ) => {
     return this.getOrCreateActiveFeed({
@@ -787,12 +801,14 @@ export class FeedsClient extends FeedsApi {
         id: feedResponse.id,
         data: feedResponse,
         watch: request?.watch,
-        fieldsToUpdate: [
-          'own_capabilities',
-          'own_follows',
-          'own_membership',
-          'own_followings',
-        ],
+        fieldsToUpdate: request?.enrich_own_fields
+          ? [
+              'own_capabilities',
+              'own_follows',
+              'own_membership',
+              'own_followings',
+            ]
+          : [],
       }),
     );
 
@@ -843,7 +859,7 @@ export class FeedsClient extends FeedsApi {
   // For follow API endpoints we update the state after HTTP response to allow queryFeeds with watch: false
   async follow(request: FollowRequest) {
     const response = await super.follow(request);
-    this.updateStateFromFollows([response.follow]);
+    this.updateStateFromFollows([response.follow], !!request.enrich_own_fields);
 
     return response;
   }
@@ -855,7 +871,7 @@ export class FeedsClient extends FeedsApi {
    */
   async followBatch(request: FollowBatchRequest) {
     const response = await super.followBatch(request);
-    this.updateStateFromFollows(response.follows);
+    this.updateStateFromFollows(response.follows, !!request.enrich_own_fields);
 
     return response;
   }
@@ -863,12 +879,16 @@ export class FeedsClient extends FeedsApi {
   async getOrCreateFollows(request: FollowBatchRequest) {
     const response = await super.getOrCreateFollows(request);
 
-    this.updateStateFromFollows(response.created);
+    this.updateStateFromFollows(response.created, !!request.enrich_own_fields);
 
     return response;
   }
 
-  async unfollow(request: { source: string; target: string, enrich_own_fields?: boolean }) {
+  async unfollow(request: {
+    source: string;
+    target: string;
+    enrich_own_fields?: boolean;
+  }) {
     const response = await super.unfollow(request);
     this.updateStateFromUnfollows([response.follow]);
 
@@ -951,8 +971,7 @@ export class FeedsClient extends FeedsApi {
     data?: FeedResponse;
     watch?: boolean;
     options?: {
-      addNewActivitiesTo?: 'start' | 'end';
-      activityAddedEventFilter?: (event: ActivityAddedEvent) => boolean;
+      onNewActivity?: OnNewActivityCallback;
     };
     fieldsToUpdate: Array<
       'own_capabilities' | 'own_follows' | 'own_followings' | 'own_membership'
@@ -969,20 +988,14 @@ export class FeedsClient extends FeedsApi {
         id,
         data,
         watch,
-        options?.addNewActivitiesTo,
-        options?.activityAddedEventFilter,
+        options?.onNewActivity,
       );
     }
 
     const feed = this.activeFeeds[fid];
 
-    if (!isCreated && options) {
-      if (options?.addNewActivitiesTo) {
-        feed.addNewActivitiesTo = options.addNewActivitiesTo;
-      }
-      if (options?.activityAddedEventFilter) {
-        feed.activityAddedEventFilter = options.activityAddedEventFilter;
-      }
+    if (!isCreated && options?.onNewActivity !== undefined) {
+      feed.onNewActivity = options.onNewActivity;
     }
 
     if (!feed.currentState.watch) {
@@ -1097,13 +1110,18 @@ export class FeedsClient extends FeedsApi {
     ];
   }
 
-  private updateStateFromFollows(follows: FollowResponse[]) {
+  private updateStateFromFollows(
+    follows: FollowResponse[],
+    hasOwnFields: boolean,
+  ) {
     follows.forEach((follow) => {
       const feeds = [
         ...this.findAllActiveFeedsByFid(follow.source_feed.feed),
         ...this.findAllActiveFeedsByFid(follow.target_feed.feed),
       ];
-      feeds.forEach((f) => handleFollowCreated.bind(f)({ follow }, false));
+      feeds.forEach((f) =>
+        handleFollowCreated.bind(f)({ follow }, false, hasOwnFields),
+      );
     });
   }
 

package/src/index.ts

@@ -1,6 +1,7 @@
 export * from '@stream-io/state-store';
 export * from './feeds-client/feeds-client';
 export * from './feed/feed';
+export { activityFilter } from './feed/activity-filter';
 export * from './gen/models';
 export * from './types';
 export * from './common/types';

package/src/types.ts

@@ -36,3 +36,20 @@ export type StreamFile = File | { name: string; uri: string; type: string };
 export type CommentParent = ActivityResponse | CommentResponse;
 
 export type ConnectedUser = OwnUserResponse & { name?: string; image?: string };
+
+/**
+ * Result of the onNewActivity callback: whether to add a new activity to the feed and where.
+ * - 'add-to-start': prepend to the activities list (e.g. new posts at top)
+ * - 'add-to-end': append to the activities list (e.g. stories)
+ * - 'ignore': do not add to the feed
+ */
+export type OnNewActivityResult = 'add-to-start' | 'add-to-end' | 'ignore';
+
+/**
+ * Callback invoked when a new activity is received (WebSocket event or addActivity HTTP response).
+ * Return how the feed should handle it.
+ */
+export type OnNewActivityCallback = (params: {
+  activity: ActivityResponse;
+  currentUser: ConnectedUser | undefined;
+}) => OnNewActivityResult;