@stream-io/feeds-client 0.3.51 → 1.1.0

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

@@ -1,7 +1,13 @@
 import { FeedsApi } from '../gen/feeds/FeedsApi';
 import type {
-  ActivityAddedEvent,
+  AcceptFeedMemberInviteResponse,
+  ActivityFeedbackRequest,
+  ActivityFeedbackResponse,
   ActivityResponse,
+  AddActivityRequest,
+  AddActivityResponse,
+  AddBookmarkRequest,
+  AddBookmarkResponse,
   AddCommentReactionRequest,
   AddCommentReactionResponse,
   AddCommentRequest,
@@ -10,8 +16,11 @@ import type {
   CastPollVoteRequest,
   CreateGuestResponse,
   DeleteActivityReactionResponse,
+  DeleteActivityResponse,
+  DeleteBookmarkResponse,
   DeleteCommentReactionResponse,
   DeleteCommentResponse,
+  DeleteFeedResponse,
   FeedResponse,
   FileUploadRequest,
   FollowBatchRequest,
@@ -22,16 +31,24 @@ import type {
   ImageSize,
   ImageUploadRequest,
   OwnBatchRequest,
+  PinActivityResponse,
   PollResponse,
   PollVoteResponse,
   PollVotesResponse,
   QueryFeedsRequest,
   QueryPollVotesRequest,
+  RejectFeedMemberInviteResponse,
   UnfollowBatchRequest,
+  UnpinActivityResponse,
+  UpdateActivityPartialResponse,
   UpdateActivityRequest,
   UpdateActivityResponse,
+  UpdateBookmarkRequest,
+  UpdateBookmarkResponse,
   UpdateCommentRequest,
   UpdateCommentResponse,
+  UpdateFeedMembersResponse,
+  UpdateFeedResponse,
   UpdateFollowRequest,
   UpdatePollPartialRequest,
   UpdatePollRequest,
@@ -41,6 +58,7 @@ import type {
 import type {
   ConnectedUser,
   FeedsEvent,
+  OnNewActivityCallback,
   StreamFile,
   TokenOrProvider,
 } from '../types';
@@ -66,22 +84,34 @@ import { StreamPoll } from '../common/Poll';
 import {
   Feed,
   type FeedState,
+  handleActivityDeleted,
   handleActivityReactionAdded,
   handleActivityReactionDeleted,
   handleActivityReactionUpdated,
   handleActivityUpdated,
+  handleActivityPinned,
+  handleActivityUnpinned,
+  handleBookmarkAdded,
+  handleBookmarkDeleted,
+  handleBookmarkUpdated,
   handleCommentAdded,
   handleCommentDeleted,
   handleCommentReactionAdded,
   handleCommentReactionDeleted,
   handleCommentUpdated,
+  handleFeedDeleted,
+  handleFeedMemberAdded,
+  handleFeedMemberRemoved,
+  handleFeedMemberUpdated,
   handleFeedUpdated,
   handleFollowCreated,
   handleFollowDeleted,
   handleFollowUpdated,
   handleWatchStarted,
   handleWatchStopped,
+  updateActivityFromFeedback,
 } from '../feed';
+import { applyNewActivityToActiveFeeds } from './apply-new-activity-to-active-feeds';
 import { handleUserUpdated } from './event-handlers';
 import {
   type SyncFailure,
@@ -561,6 +591,66 @@ export class FeedsClient extends FeedsApi {
     return response;
   };
 
+  updateActivityPartial = async (
+    ...args: Parameters<FeedsApi['updateActivityPartial']>
+  ): Promise<StreamResponse<UpdateActivityPartialResponse>> => {
+    const response = await super.updateActivityPartial(...args);
+    for (const feed of this.allActiveFeeds) {
+      handleActivityUpdated.bind(feed)(response, false);
+    }
+    return response;
+  };
+
+  deleteActivity = async (
+    ...args: Parameters<FeedsApi['deleteActivity']>
+  ): Promise<StreamResponse<DeleteActivityResponse>> => {
+    const response = await super.deleteActivity(...args);
+    const activityId = args[0].id;
+    for (const feed of this.allActiveFeeds) {
+      handleActivityDeleted.bind(feed)(
+        { activity: { id: activityId } } as Parameters<
+          typeof handleActivityDeleted
+        >[0],
+        false,
+      );
+    }
+    this.activeActivities = this.activeActivities.filter(
+      (activity) => activity.id !== activityId,
+    );
+    return response;
+  };
+
+  activityFeedback = async (
+    request: ActivityFeedbackRequest & { activity_id: string },
+  ): Promise<StreamResponse<ActivityFeedbackResponse>> => {
+    const response = await super.activityFeedback(request);
+    if (request.hide !== undefined) {
+      const feedback = {
+        activity_id: request.activity_id,
+        action: 'hide' as const,
+        value: request.hide ? 'true' : 'false',
+      };
+      for (const feed of this.allActiveFeeds) {
+        const {
+          activities: currentActivities,
+          pinned_activities: currentPinnedActivities,
+        } = feed.currentState;
+        const [result1, result2] = [
+          updateActivityFromFeedback(feedback, currentActivities),
+          updateActivityFromFeedback(feedback, currentPinnedActivities),
+        ];
+
+        if (result1.changed || result2.changed) {
+          feed.state.partialNext({
+            activities: result1.entities,
+            pinned_activities: result2.entities,
+          });
+        }
+      }
+    }
+    return response;
+  };
+
   addComment = async (
     request: AddCommentRequest,
   ): Promise<StreamResponse<AddCommentResponse>> => {
@@ -614,6 +704,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;
@@ -677,6 +780,160 @@ export class FeedsClient extends FeedsApi {
     return response;
   };
 
+  addBookmark = async (
+    request: AddBookmarkRequest & { activity_id: string },
+  ): Promise<StreamResponse<AddBookmarkResponse>> => {
+    const response = await super.addBookmark(request);
+    for (const feed of this.allActiveFeeds) {
+      handleBookmarkAdded.bind(feed)(response);
+    }
+    return response;
+  };
+
+  updateBookmark = async (
+    request: UpdateBookmarkRequest & { activity_id: string },
+  ): Promise<StreamResponse<UpdateBookmarkResponse>> => {
+    const response = await super.updateBookmark(request);
+    for (const feed of this.allActiveFeeds) {
+      handleBookmarkUpdated.bind(feed)(response);
+    }
+    return response;
+  };
+
+  deleteBookmark = async (request: {
+    activity_id: string;
+    folder_id?: string;
+  }): Promise<StreamResponse<DeleteBookmarkResponse>> => {
+    const response = await super.deleteBookmark(request);
+    for (const feed of this.allActiveFeeds) {
+      handleBookmarkDeleted.bind(feed)(response);
+    }
+    return response;
+  };
+
+  pinActivity = async (
+    ...args: Parameters<FeedsApi['pinActivity']>
+  ): Promise<StreamResponse<PinActivityResponse>> => {
+    const response = await super.pinActivity(...args);
+    const feedIds =
+      response.activity?.feeds ?? (response.feed ? [response.feed] : []);
+    for (const fid of feedIds) {
+      const feed = this.activeFeeds[fid];
+      if (feed) {
+        handleActivityPinned.bind(feed)(
+          { pinned_activity: response } as Parameters<
+            typeof handleActivityPinned
+          >[0],
+          false,
+        );
+      }
+    }
+    return response;
+  };
+
+  unpinActivity = async (
+    ...args: Parameters<FeedsApi['unpinActivity']>
+  ): Promise<StreamResponse<UnpinActivityResponse>> => {
+    const response = await super.unpinActivity(...args);
+    const feedIds =
+      response.activity?.feeds ?? (response.feed ? [response.feed] : []);
+    for (const fid of feedIds) {
+      const feed = this.activeFeeds[fid];
+      if (feed) {
+        handleActivityUnpinned.bind(feed)(
+          {
+            pinned_activity: {
+              ...response,
+              created_at: new Date(),
+            },
+          } as Parameters<typeof handleActivityUnpinned>[0],
+          false,
+        );
+      }
+    }
+    return response;
+  };
+
+  updateFeed = async (
+    ...args: Parameters<FeedsApi['updateFeed']>
+  ): Promise<StreamResponse<UpdateFeedResponse>> => {
+    const response = await super.updateFeed(...args);
+    const fid = `${args[0].feed_group_id}:${args[0].feed_id}`;
+    const feed = this.activeFeeds[fid];
+    if (feed) {
+      handleFeedUpdated.call(feed, { feed: response.feed } as Parameters<
+        typeof handleFeedUpdated
+      >[0]);
+    }
+    return response;
+  };
+
+  deleteFeed = async (
+    ...args: Parameters<FeedsApi['deleteFeed']>
+  ): Promise<StreamResponse<DeleteFeedResponse>> => {
+    const response = await super.deleteFeed(...args);
+    const fid = `${args[0].feed_group_id}:${args[0].feed_id}`;
+    const feed = this.activeFeeds[fid];
+    if (feed) {
+      handleFeedDeleted.call(feed, {
+        created_at: new Date(),
+      } as Parameters<typeof handleFeedDeleted>[0]);
+      // If the feed is not watched, clean up immediately (no WS event will follow).
+      // If watched, the WS handler will clean up after dispatching the event.
+      if (!feed.currentState.watch) {
+        delete this.activeFeeds[fid];
+        this.activeActivities = this.activeActivities.filter(
+          (activity) => getFeed.call(activity)?.feed !== fid,
+        );
+      }
+    }
+    return response;
+  };
+
+  updateFeedMembers = async (
+    ...args: Parameters<FeedsApi['updateFeedMembers']>
+  ): Promise<StreamResponse<UpdateFeedMembersResponse>> => {
+    const response = await super.updateFeedMembers(...args);
+    const fid = `${args[0].feed_group_id}:${args[0].feed_id}`;
+    const feed = this.activeFeeds[fid];
+    if (feed) {
+      for (const member of response.added) {
+        handleFeedMemberAdded.call(feed, { member }, false);
+      }
+      for (const member of response.updated) {
+        handleFeedMemberUpdated.call(feed, { member }, false);
+      }
+      for (const memberId of response.removed_ids) {
+        handleFeedMemberRemoved.call(feed, { member_id: memberId }, false);
+      }
+    }
+    return response;
+  };
+
+  acceptFeedMemberInvite = async (
+    ...args: Parameters<FeedsApi['acceptFeedMemberInvite']>
+  ): Promise<StreamResponse<AcceptFeedMemberInviteResponse>> => {
+    const response = await super.acceptFeedMemberInvite(...args);
+    const fid = `${args[0].feed_group_id}:${args[0].feed_id}`;
+    const feed = this.activeFeeds[fid];
+    if (feed) {
+      handleFeedMemberUpdated.call(feed, { member: response.member }, false);
+    }
+    return response;
+  };
+
+  rejectFeedMemberInvite = async (
+    ...args: Parameters<FeedsApi['rejectFeedMemberInvite']>
+  ): Promise<StreamResponse<RejectFeedMemberInviteResponse>> => {
+    const response = await super.rejectFeedMemberInvite(...args);
+    const fid = `${args[0].feed_group_id}:${args[0].feed_id}`;
+    const feed = this.activeFeeds[fid];
+    if (feed) {
+      handleFeedMemberUpdated.call(feed, { member: response.member }, false);
+    }
+    return response;
+  };
+
   queryPollAnswers = async (
     request: QueryPollVotesRequest & { poll_id: string; user_id?: string },
   ): Promise<StreamResponse<PollVotesResponse>> => {
@@ -737,16 +994,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 +1042,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',
+            ]
+          : [],
       }),
     );
 
@@ -840,10 +1097,24 @@ export class FeedsClient extends FeedsApi {
     return response;
   }
 
+  async acceptFollow(...args: Parameters<FeedsApi['acceptFollow']>) {
+    const response = await super.acceptFollow(...args);
+
+    [
+      response.follow.source_feed.feed,
+      response.follow.target_feed.feed,
+    ].forEach((fid) => {
+      const feeds = this.findAllActiveFeedsByFid(fid);
+      feeds.forEach((f) => handleFollowUpdated.bind(f)(response, false));
+    });
+
+    return response;
+  }
+
   // 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 +1126,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 +1134,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 +1226,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 +1243,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 +1365,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/gen/feeds/FeedsApi.ts

@@ -84,6 +84,8 @@ import type {
   QueryBookmarkFoldersResponse,
   QueryBookmarksRequest,
   QueryBookmarksResponse,
+  QueryCollectionsRequest,
+  QueryCollectionsResponse,
   QueryCommentReactionsRequest,
   QueryCommentReactionsResponse,
   QueryCommentsRequest,
@@ -106,6 +108,7 @@ import type {
   RejectFeedMemberInviteResponse,
   RejectFollowRequest,
   RejectFollowResponse,
+  RemoveUserGroupMembersRequest,
   RemoveUserGroupMembersResponse,
   Response,
   RestoreActivityRequest,
@@ -114,6 +117,8 @@ import type {
   SharedLocationResponse,
   SharedLocationsResponse,
   SingleFollowResponse,
+  TrackActivityMetricsRequest,
+  TrackActivityMetricsResponse,
   UnblockUsersRequest,
   UnblockUsersResponse,
   UnfollowBatchRequest,
@@ -413,6 +418,29 @@ export class FeedsApi {
     return { ...response.body, metadata: response.metadata };
   }
 
+  async trackActivityMetrics(
+    request: TrackActivityMetricsRequest,
+  ): Promise<StreamResponse<TrackActivityMetricsResponse>> {
+    const body = {
+      events: request?.events,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<TrackActivityMetricsResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/activities/metrics/track',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.TrackActivityMetricsResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
   async queryActivities(
     request?: QueryActivitiesRequest,
   ): Promise<StreamResponse<QueryActivitiesResponse>> {
@@ -1020,6 +1048,33 @@ export class FeedsApi {
     return { ...response.body, metadata: response.metadata };
   }
 
+  async queryCollections(
+    request?: QueryCollectionsRequest,
+  ): Promise<StreamResponse<QueryCollectionsResponse>> {
+    const body = {
+      limit: request?.limit,
+      next: request?.next,
+      prev: request?.prev,
+      sort: request?.sort,
+      filter: request?.filter,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<QueryCollectionsResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/collections/query',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.QueryCollectionsResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
   async getComments(request: {
     object_id: string;
     object_type: string;
@@ -1112,6 +1167,7 @@ export class FeedsApi {
   ): Promise<StreamResponse<QueryCommentsResponse>> {
     const body = {
       filter: request?.filter,
+      id_around: request?.id_around,
       limit: request?.limit,
       next: request?.next,
       prev: request?.prev,
@@ -2649,25 +2705,36 @@ export class FeedsApi {
     return { ...response.body, metadata: response.metadata };
   }
 
-  async removeUserGroupMembers(request: {
-    id: string;
-  }): Promise<StreamResponse<RemoveUserGroupMembersResponse>> {
+  async addUserGroupMembers(
+    request: AddUserGroupMembersRequest & { id: string },
+  ): Promise<StreamResponse<AddUserGroupMembersResponse>> {
     const pathParams = {
       id: request?.id,
     };
+    const body = {
+      member_ids: request?.member_ids,
+      team_id: request?.team_id,
+    };
 
     const response = await this.apiClient.sendRequest<
-      StreamResponse<RemoveUserGroupMembersResponse>
-    >('DELETE', '/api/v2/usergroups/{id}/members', pathParams, undefined);
+      StreamResponse<AddUserGroupMembersResponse>
+    >(
+      'POST',
+      '/api/v2/usergroups/{id}/members',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
 
-    decoders.RemoveUserGroupMembersResponse?.(response.body);
+    decoders.AddUserGroupMembersResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
   }
 
-  async addUserGroupMembers(
-    request: AddUserGroupMembersRequest & { id: string },
-  ): Promise<StreamResponse<AddUserGroupMembersResponse>> {
+  async removeUserGroupMembers(
+    request: RemoveUserGroupMembersRequest & { id: string },
+  ): Promise<StreamResponse<RemoveUserGroupMembersResponse>> {
     const pathParams = {
       id: request?.id,
     };
@@ -2677,17 +2744,17 @@ export class FeedsApi {
     };
 
     const response = await this.apiClient.sendRequest<
-      StreamResponse<AddUserGroupMembersResponse>
+      StreamResponse<RemoveUserGroupMembersResponse>
     >(
       'POST',
-      '/api/v2/usergroups/{id}/members',
+      '/api/v2/usergroups/{id}/members/delete',
       pathParams,
       undefined,
       body,
       'application/json',
     );
 
-    decoders.AddUserGroupMembersResponse?.(response.body);
+    decoders.RemoveUserGroupMembersResponse?.(response.body);
 
     return { ...response.body, metadata: response.metadata };
   }

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

@@ -1554,6 +1554,13 @@ decoders.QueryBookmarksResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.QueryCollectionsResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    collections: { type: 'CollectionResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.QueryCommentReactionsResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     reactions: { type: 'FeedsReactionResponse', isSingle: false },