@stream-io/feeds-client 1.0.0 → 1.1.0

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

@@ -1,5 +1,6 @@
 import type { Feed } from '../..';
 import type {
+  ActivityResponse,
   AggregatedActivityResponse,
   NotificationFeedUpdatedEvent,
   NotificationStatusResponse,
@@ -35,15 +36,18 @@ export const updateNotificationFeedFromEvent = (
   event: NotificationFeedUpdatedEvent,
   currentAggregatedActivities?: AggregatedActivityResponse[],
   currentNotificationStatus?: NotificationStatusResponse,
+  currentActivities?: ActivityResponse[],
 ): UpdateStateResult<{
   data?: {
     notification_status?: NotificationStatusResponse;
     aggregated_activities?: AggregatedActivityResponse[];
+    activities?: ActivityResponse[];
   };
 }> => {
   const updates: {
     notification_status?: NotificationStatusResponse;
     aggregated_activities?: AggregatedActivityResponse[];
+    activities?: ActivityResponse[];
   } = {};
 
   if (event.notification_status) {
@@ -58,11 +62,71 @@ export const updateNotificationFeedFromEvent = (
     }
   }
 
+  // Determine effective notification status (prefer new from event, fall back to current)
+  const effectiveStatus =
+    event.notification_status ?? currentNotificationStatus;
+  const lastReadAt = effectiveStatus?.last_read_at;
+  const lastSeenAt = effectiveStatus?.last_seen_at;
+  const readActivities = effectiveStatus?.read_activities ?? [];
+  const seenActivities = effectiveStatus?.seen_activities ?? [];
+
+  // For flat feeds — update currentActivities with is_read/is_seen
+  if (
+    currentActivities?.length &&
+    !currentAggregatedActivities?.length &&
+    effectiveStatus
+  ) {
+    let anyChanged = false;
+    const updatedActivities = currentActivities.map((activity) => {
+      const isRead =
+        (lastReadAt != null &&
+          activity.updated_at.getTime() < lastReadAt.getTime()) ||
+        readActivities.includes(activity.id);
+      const isSeen =
+        (lastSeenAt != null &&
+          activity.updated_at.getTime() < lastSeenAt.getTime()) ||
+        seenActivities.includes(activity.id);
+      if (activity.is_read !== isRead || activity.is_seen !== isSeen) {
+        anyChanged = true;
+        return { ...activity, is_read: isRead, is_seen: isSeen };
+      }
+      return activity;
+    });
+    if (anyChanged) {
+      updates.activities = updatedActivities;
+    }
+  }
+
+  // For aggregated feeds — update aggregated_activities with is_read/is_seen
+  if (currentAggregatedActivities?.length && effectiveStatus) {
+    const baseAggregated = currentAggregatedActivities;
+    let anyChanged = false;
+    const updatedAggregated = baseAggregated.map((group) => {
+      const isRead =
+        (lastReadAt != null &&
+          group.updated_at.getTime() < lastReadAt.getTime()) ||
+        readActivities.includes(group.group);
+      const isSeen =
+        (lastSeenAt != null &&
+          group.updated_at.getTime() < lastSeenAt.getTime()) ||
+        seenActivities.includes(group.group);
+      if (group.is_read !== isRead || group.is_seen !== isSeen) {
+        anyChanged = true;
+        return { ...group, is_read: isRead, is_seen: isSeen };
+      }
+      return group;
+    });
+    if (anyChanged) {
+      updates.aggregated_activities = updatedAggregated;
+    }
+  }
+
+  // Leave this to the end, because notification_status may not be 100% accurate (only includes last 100 activities)
   if (event.aggregated_activities && currentAggregatedActivities) {
     const aggregatedActivitiesResult = addAggregatedActivitiesToState(
       event.aggregated_activities,
-      currentAggregatedActivities,
-      'start',
+      updates.aggregated_activities ?? currentAggregatedActivities,
+      'replace-then-start',
     );
 
     if (aggregatedActivitiesResult.changed) {
@@ -91,11 +155,13 @@ export function handleNotificationFeedUpdated(
     event,
     this.currentState.aggregated_activities,
     this.currentState.notification_status,
+    this.currentState.activities,
   );
   if (result.changed) {
     this.state.partialNext({
       notification_status: result.data?.notification_status,
       aggregated_activities: result.data?.aggregated_activities,
+      activities: result.data?.activities ?? this.currentState.activities,
     });
   }
 }

package/src/feed/event-handlers/story-feeds/handle-story-feeds-updated.ts

@@ -79,7 +79,7 @@ export function updateStoriesFeedFromEvent(
     const aggregatedActivitiesResult = addAggregatedActivitiesToState(
       event.aggregated_activities,
       aggregatedActivities,
-      'replace',
+      'replace-then-end',
     );
 
     if (aggregatedActivitiesResult.changed) {

package/src/feed/feed.ts

@@ -38,9 +38,9 @@ import {
   handleBookmarkAdded,
   handleActivityDeleted,
   handleActivityRemovedFromFeed,
+  handleFeedDeleted,
   handleFeedUpdated,
   handleNotificationFeedUpdated,
-  handleActivityMarked,
   handleActivityReactionAdded,
   handleActivityReactionDeleted,
   handleActivityReactionUpdated,
@@ -50,6 +50,8 @@ import {
   addAggregatedActivitiesToState,
   updateNotificationStatus,
   handleStoriesFeedUpdated,
+  handleActivityPinned,
+  handleActivityUnpinned,
 } from './event-handlers';
 import { capitalize } from '../common/utils';
 import type {
@@ -181,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,
@@ -204,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,

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

@@ -1,8 +1,13 @@
 import { FeedsApi } from '../gen/feeds/FeedsApi';
 import type {
+  AcceptFeedMemberInviteResponse,
+  ActivityFeedbackRequest,
+  ActivityFeedbackResponse,
   ActivityResponse,
   AddActivityRequest,
   AddActivityResponse,
+  AddBookmarkRequest,
+  AddBookmarkResponse,
   AddCommentReactionRequest,
   AddCommentReactionResponse,
   AddCommentRequest,
@@ -11,8 +16,11 @@ import type {
   CastPollVoteRequest,
   CreateGuestResponse,
   DeleteActivityReactionResponse,
+  DeleteActivityResponse,
+  DeleteBookmarkResponse,
   DeleteCommentReactionResponse,
   DeleteCommentResponse,
+  DeleteFeedResponse,
   FeedResponse,
   FileUploadRequest,
   FollowBatchRequest,
@@ -23,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,
@@ -68,21 +84,32 @@ 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';
@@ -564,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>> => {
@@ -693,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>> => {
@@ -856,6 +1097,20 @@ 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);

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 },