@stream-io/feeds-client 1.0.0 → 1.2.0

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,161 @@ 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]);
+    }
+    this.checkIfOwnFieldsChanged(response.feed, !!args[0].enrich_own_fields);
+    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>> => {
@@ -853,6 +1095,28 @@ export class FeedsClient extends FeedsApi {
       feeds.forEach((f) => handleFollowUpdated.bind(f)(response, false));
     });
 
+    this.checkIfOwnFieldsChanged(
+      response.follow.source_feed,
+      !!request.enrich_own_fields,
+    );
+    this.checkIfOwnFieldsChanged(
+      response.follow.target_feed,
+      !!request.enrich_own_fields,
+    );
+    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;
   }
 
@@ -860,7 +1124,14 @@ export class FeedsClient extends FeedsApi {
   async follow(request: FollowRequest) {
     const response = await super.follow(request);
     this.updateStateFromFollows([response.follow], !!request.enrich_own_fields);
-
+    this.checkIfOwnFieldsChanged(
+      response.follow.source_feed,
+      !!request.enrich_own_fields,
+    );
+    this.checkIfOwnFieldsChanged(
+      response.follow.target_feed,
+      !!request.enrich_own_fields,
+    );
     return response;
   }
 
@@ -872,7 +1143,11 @@ export class FeedsClient extends FeedsApi {
   async followBatch(request: FollowBatchRequest) {
     const response = await super.followBatch(request);
     this.updateStateFromFollows(response.follows, !!request.enrich_own_fields);
-
+    const enrichOwnFields = !!request.enrich_own_fields;
+    for (const follow of response.follows) {
+      this.checkIfOwnFieldsChanged(follow.source_feed, enrichOwnFields);
+      this.checkIfOwnFieldsChanged(follow.target_feed, enrichOwnFields);
+    }
     return response;
   }
 
@@ -880,7 +1155,12 @@ export class FeedsClient extends FeedsApi {
     const response = await super.getOrCreateFollows(request);
 
     this.updateStateFromFollows(response.created, !!request.enrich_own_fields);
-
+    const enrichOwnFields = !!request.enrich_own_fields;
+    const allFollows = [...response.created, ...response.follows];
+    for (const follow of allFollows) {
+      this.checkIfOwnFieldsChanged(follow.source_feed, enrichOwnFields);
+      this.checkIfOwnFieldsChanged(follow.target_feed, enrichOwnFields);
+    }
     return response;
   }
 
@@ -891,14 +1171,25 @@ export class FeedsClient extends FeedsApi {
   }) {
     const response = await super.unfollow(request);
     this.updateStateFromUnfollows([response.follow]);
-
+    this.checkIfOwnFieldsChanged(
+      response.follow.source_feed,
+      !!request.enrich_own_fields,
+    );
+    this.checkIfOwnFieldsChanged(
+      response.follow.target_feed,
+      !!request.enrich_own_fields,
+    );
     return response;
   }
 
   async getOrCreateUnfollows(request: UnfollowBatchRequest) {
     const response = await super.getOrCreateUnfollows(request);
     this.updateStateFromUnfollows(response.follows);
-
+    const enrichOwnFields = !!request.enrich_own_fields;
+    for (const follow of response.follows) {
+      this.checkIfOwnFieldsChanged(follow.source_feed, enrichOwnFields);
+      this.checkIfOwnFieldsChanged(follow.target_feed, enrichOwnFields);
+    }
     return response;
   }
 
@@ -998,6 +1289,7 @@ export class FeedsClient extends FeedsApi {
       feed.onNewActivity = options.onNewActivity;
     }
 
+    let wasFullUpdate = isCreated;
     if (!feed.currentState.watch) {
       if (!isCreated && data) {
         if (
@@ -1005,54 +1297,76 @@ export class FeedsClient extends FeedsApi {
           data.updated_at.getTime()
         ) {
           handleFeedUpdated.call(feed, { feed: data });
-        } else if (
-          (feed.currentState.updated_at?.getTime() ?? 0) ===
-          data.updated_at.getTime()
-        ) {
-          const fieldsToUpdateData: Array<keyof FeedResponse> = [];
-          const fieldChecks: Array<
-            [
-              (
-                | 'own_capabilities'
-                | 'own_follows'
-                | 'own_membership'
-                | 'own_followings'
-              ),
-              (currentState: FeedState, newState: FeedResponse) => boolean,
-            ]
-          > = [
-            ['own_capabilities', isOwnCapabilitiesEqual],
-            ['own_follows', isOwnFollowsEqual],
-            ['own_membership', isOwnMembershipEqual],
-            ['own_followings', isOwnFollowingsEqual],
-          ];
-          fieldChecks.forEach(([field, isEqual]) => {
-            if (
-              fieldsToUpdate.includes(field) &&
-              !isEqual(feed.currentState, data)
-            ) {
-              fieldsToUpdateData.push(field);
-            }
-          });
-          if (fieldsToUpdateData.length > 0) {
-            const fieldsToUpdatePayload = fieldsToUpdateData.reduce(
-              (acc: Partial<FeedResponse>, field) => {
-                // @ts-expect-error TODO: fix this
-                acc[field] = data[field];
-                return acc;
-              },
-              {},
-            );
-            feed.state.partialNext(fieldsToUpdatePayload);
-          }
+          wasFullUpdate = true;
         }
       }
       if (watch) handleWatchStarted.call(feed);
     }
 
+    // If we didn't do a full update, check if own_* fields have changed
+    if (!wasFullUpdate && data && fieldsToUpdate.length > 0) {
+      const fieldsToUpdateData: Array<keyof FeedResponse> = [];
+      const fieldChecks: Array<
+        [
+          (
+            | 'own_capabilities'
+            | 'own_follows'
+            | 'own_membership'
+            | 'own_followings'
+          ),
+          (currentState: FeedState, newState: FeedResponse) => boolean,
+        ]
+      > = [
+        ['own_capabilities', isOwnCapabilitiesEqual],
+        ['own_follows', isOwnFollowsEqual],
+        ['own_membership', isOwnMembershipEqual],
+        ['own_followings', isOwnFollowingsEqual],
+      ];
+      fieldChecks.forEach(([field, isEqual]) => {
+        if (
+          fieldsToUpdate.includes(field) &&
+          !isEqual(feed.currentState, data)
+        ) {
+          fieldsToUpdateData.push(field);
+        }
+      });
+      if (fieldsToUpdateData.length > 0) {
+        const fieldsToUpdatePayload = fieldsToUpdateData.reduce(
+          (acc: Partial<FeedResponse>, field) => {
+            // @ts-expect-error TODO: fix this
+            acc[field] = data[field];
+            return acc;
+          },
+          {},
+        );
+        feed.state.partialNext(fieldsToUpdatePayload);
+      }
+    }
+
     return feed;
   };
 
+  // Used when updating from HTTP responses to check if own_* fields have changed
+  // It'll do a state update if WS update ran before HTTP, but WS doesn't have own_* fields
+  private checkIfOwnFieldsChanged(
+    feed: FeedResponse,
+    enrichOwnFields: boolean,
+  ) {
+    if (!enrichOwnFields || !this.activeFeeds[feed.feed]) return false;
+
+    this.getOrCreateActiveFeed({
+      group: feed.group_id,
+      id: feed.id,
+      data: feed,
+      fieldsToUpdate: [
+        'own_capabilities',
+        'own_follows',
+        'own_membership',
+        'own_followings',
+      ],
+    });
+  }
+
   private findAllActiveFeedsByActivityId(activityId: string) {
     return [
       ...Object.values(this.activeFeeds),

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