@stream-io/feeds-client 0.3.46 → 0.3.48

package/src/common/Poll.ts

@@ -6,9 +6,6 @@ import type {
   PollUpdatedFeedEvent,
   WSEvent,
   PollClosedFeedEvent,
-  PollVoteCastedFeedEvent,
-  PollVoteChangedFeedEvent,
-  PollVoteRemovedFeedEvent,
   PollResponseData,
 } from '../gen/models';
 
@@ -20,21 +17,14 @@ const isPollClosedEventEvent = (
   e: WSEvent,
 ): e is { type: 'feeds.poll.closed' } & PollClosedFeedEvent =>
   e.type === 'feeds.poll.closed';
-const isPollVoteCastedEvent = (
-  e: WSEvent,
-): e is { type: 'feeds.poll.vote_casted' } & PollVoteCastedFeedEvent =>
-  e.type === 'feeds.poll.vote_casted';
-const isPollVoteChangedEvent = (
-  e: WSEvent,
-): e is { type: 'feeds.poll.vote_changed' } & PollVoteChangedFeedEvent =>
-  e.type === 'feeds.poll.vote_changed';
-const isPollVoteRemovedEvent = (
-  e: WSEvent,
-): e is { type: 'feeds.poll.vote_removed' } & PollVoteRemovedFeedEvent =>
-  e.type === 'feeds.poll.vote_removed';
 
-export const isVoteAnswer = (vote: PollVoteResponseData) =>
-  !!vote?.answer_text;
+export type PollVotePayload = {
+  poll: PollResponseData;
+  poll_vote: PollVoteResponseData;
+  created_at: Date;
+};
+
+export const isVoteAnswer = (vote: PollVoteResponseData) => !!vote?.answer_text;
 
 export type PollAnswersQueryParams = QueryPollVotesRequest & {
   poll_id: string;
@@ -126,28 +116,43 @@ export class StreamPoll {
     });
   };
 
-  public handleVoteCasted = (event: PollVoteCastedFeedEvent) => {
+  public handleVoteCasted = (event: PollVotePayload) => {
     if (event.poll?.id && event.poll.id !== this.id) return;
-    if (!isPollVoteCastedEvent(event as WSEvent)) return;
     const currentState = this.data;
     const isOwnVote =
       event.poll_vote.user_id ===
       this.client.state.getLatestValue().connected_user?.id;
+
+    if (isOwnVote) {
+      const alreadyApplied = isVoteAnswer(event.poll_vote)
+        ? currentState.own_answer?.id === event.poll_vote.id
+        : !!event.poll_vote.option_id &&
+          currentState.own_votes_by_option_id[event.poll_vote.option_id]?.id ===
+            event.poll_vote.id;
+      if (alreadyApplied) return;
+    }
+
     let latestAnswers = [...currentState.latest_answers];
     let ownAnswer = currentState.own_answer;
-    const ownVotesByOptionId = currentState.own_votes_by_option_id;
+    let ownVotesByOptionId = currentState.own_votes_by_option_id;
     let maxVotedOptionIds = currentState.max_voted_option_ids;
 
     if (isOwnVote) {
       if (isVoteAnswer(event.poll_vote)) {
         ownAnswer = event.poll_vote;
       } else if (event.poll_vote.option_id) {
-        ownVotesByOptionId[event.poll_vote.option_id] = event.poll_vote;
+        ownVotesByOptionId = {
+          ...ownVotesByOptionId,
+          [event.poll_vote.option_id]: event.poll_vote,
+        };
       }
     }
 
     if (isVoteAnswer(event.poll_vote)) {
-      latestAnswers = [event.poll_vote, ...latestAnswers];
+      latestAnswers = [
+        event.poll_vote,
+        ...latestAnswers.filter((a) => a.id !== event.poll_vote.id),
+      ];
     } else {
       maxVotedOptionIds = getMaxVotedOptionIds(
         event.poll.vote_counts_by_option,
@@ -173,14 +178,23 @@ export class StreamPoll {
     });
   };
 
-  public handleVoteChanged = (event: PollVoteChangedFeedEvent) => {
+  public handleVoteChanged = (event: PollVotePayload) => {
     // this event is triggered only when event.poll.enforce_unique_vote === true
     if (event.poll?.id && event.poll.id !== this.id) return;
-    if (!isPollVoteChangedEvent(event as WSEvent)) return;
     const currentState = this.data;
     const isOwnVote =
       event.poll_vote.user_id ===
       this.client.state.getLatestValue().connected_user?.id;
+
+    if (isOwnVote) {
+      const alreadyApplied = isVoteAnswer(event.poll_vote)
+        ? currentState.own_answer?.id === event.poll_vote.id
+        : !!event.poll_vote.option_id &&
+          currentState.own_votes_by_option_id[event.poll_vote.option_id]?.id ===
+            event.poll_vote.id;
+      if (alreadyApplied) return;
+    }
+
     let latestAnswers = [...currentState.latest_answers];
     let ownAnswer = currentState.own_answer;
     let ownVotesByOptionId = currentState.own_votes_by_option_id;
@@ -246,13 +260,20 @@ export class StreamPoll {
     });
   };
 
-  public handleVoteRemoved = (event: PollVoteRemovedFeedEvent) => {
+  public handleVoteRemoved = (event: PollVotePayload) => {
     if (event.poll?.id && event.poll.id !== this.id) return;
-    if (!isPollVoteRemovedEvent(event as WSEvent)) return;
     const currentState = this.data;
     const isOwnVote =
       event.poll_vote.user_id ===
       this.client.state.getLatestValue().connected_user?.id;
+
+    if (isOwnVote) {
+      const alreadyApplied = isVoteAnswer(event.poll_vote)
+        ? !currentState.own_answer
+        : !!event.poll_vote.option_id &&
+          !(event.poll_vote.option_id in currentState.own_votes_by_option_id);
+      if (alreadyApplied) return;
+    }
     let latestAnswers = [...currentState.latest_answers];
     let ownAnswer = currentState.own_answer;
     const ownVotesByOptionId = { ...currentState.own_votes_by_option_id };

package/src/feed/event-handlers/activity-updater.ts

@@ -11,5 +11,7 @@ export const updateActivity = ({
     ...newActivtiy,
     own_reactions: currentActivity.own_reactions,
     own_bookmarks: currentActivity.own_bookmarks,
+    friend_reactions: currentActivity.friend_reactions,
+    friend_reaction_count: currentActivity.friend_reaction_count,
   };
 };

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

@@ -7,6 +7,7 @@ import type {
   AddCommentRequest,
   AddCommentResponse,
   AddReactionRequest,
+  CastPollVoteRequest,
   CreateGuestResponse,
   DeleteActivityReactionResponse,
   DeleteCommentReactionResponse,
@@ -22,6 +23,7 @@ import type {
   ImageUploadRequest,
   OwnBatchRequest,
   PollResponse,
+  PollVoteResponse,
   PollVotesResponse,
   QueryFeedsRequest,
   QueryPollVotesRequest,
@@ -352,17 +354,16 @@ export class FeedsClient extends FeedsApi {
 
   public hydratePollCache(activities: ActivityResponse[]) {
     for (const activity of activities) {
-      if (!activity.poll) {
-        continue;
-      }
-      const pollResponse = activity.poll;
-      const pollFromCache = this.pollFromState(pollResponse.id);
-      if (!pollFromCache) {
-        const poll = new StreamPoll({ client: this, poll: pollResponse });
-        this.polls_by_id.set(poll.id, poll);
-      } else {
-        pollFromCache.reinitializeState(pollResponse);
-      }
+      const polls = [activity.poll, activity.parent?.poll].filter((p) => !!p);
+      polls.forEach((pollResponse) => {
+        const pollFromCache = this.pollFromState(pollResponse.id);
+        if (!pollFromCache) {
+          const poll = new StreamPoll({ client: this, poll: pollResponse });
+          this.polls_by_id.set(poll.id, poll);
+        } else {
+          pollFromCache.reinitializeState(pollResponse);
+        }
+      });
     }
   }
 
@@ -462,6 +463,46 @@ export class FeedsClient extends FeedsApi {
     });
   };
 
+  castPollVote = async (
+    request: CastPollVoteRequest & { activity_id: string; poll_id: string },
+  ): Promise<StreamResponse<PollVoteResponse>> => {
+    const poll = this.pollFromState(request.poll_id);
+    const response = await super.castPollVote(request);
+    if (response.poll && response.vote && poll) {
+      const payload = {
+        poll: response.poll,
+        poll_vote: response.vote,
+        created_at: new Date(),
+      };
+      if (
+        poll.data.enforce_unique_vote &&
+        Object.keys(poll.data.own_votes_by_option_id).length > 0
+      ) {
+        poll.handleVoteChanged(payload);
+      } else {
+        poll.handleVoteCasted(payload);
+      }
+    }
+    return response;
+  };
+
+  deletePollVote = async (request: {
+    activity_id: string;
+    poll_id: string;
+    vote_id: string;
+    user_id?: string;
+  }): Promise<StreamResponse<PollVoteResponse>> => {
+    const response = await super.deletePollVote(request);
+    if (response.poll && response.vote) {
+      this.pollFromState(request.poll_id)?.handleVoteRemoved({
+        poll: response.poll,
+        poll_vote: response.vote,
+        created_at: new Date(),
+      });
+    }
+    return response;
+  };
+
   uploadFile = (
     request?: Omit<FileUploadRequest, 'file'> & { file?: StreamFile | string },
   ) => {

package/src/gen/feeds/FeedApi.ts

@@ -10,6 +10,8 @@ import type {
   PinActivityResponse,
   QueryFeedMembersRequest,
   QueryFeedMembersResponse,
+  QueryPinnedActivitiesRequest,
+  QueryPinnedActivitiesResponse,
   RejectFeedMemberInviteRequest,
   RejectFeedMemberInviteResponse,
   Response,
@@ -127,6 +129,16 @@ export class FeedApi {
     });
   }
 
+  queryPinnedActivities(
+    request?: QueryPinnedActivitiesRequest,
+  ): Promise<StreamResponse<QueryPinnedActivitiesResponse>> {
+    return this.feedsApi.queryPinnedActivities({
+      feed_id: this.id,
+      feed_group_id: this.group,
+      ...request,
+    });
+  }
+
   stopWatching(request?: {
     connection_id?: string;
   }): Promise<StreamResponse<Response>> {

package/src/gen/feeds/FeedsApi.ts

@@ -88,6 +88,8 @@ import type {
   QueryFeedsResponse,
   QueryFollowsRequest,
   QueryFollowsResponse,
+  QueryPinnedActivitiesRequest,
+  QueryPinnedActivitiesResponse,
   QueryPollVotesRequest,
   QueryPollsRequest,
   QueryPollsResponse,
@@ -1611,6 +1613,40 @@ export class FeedsApi {
     return { ...response.body, metadata: response.metadata };
   }
 
+  async queryPinnedActivities(
+    request: QueryPinnedActivitiesRequest & {
+      feed_group_id: string;
+      feed_id: string;
+    },
+  ): Promise<StreamResponse<QueryPinnedActivitiesResponse>> {
+    const pathParams = {
+      feed_group_id: request?.feed_group_id,
+      feed_id: request?.feed_id,
+    };
+    const body = {
+      limit: request?.limit,
+      next: request?.next,
+      prev: request?.prev,
+      sort: request?.sort,
+      filter: request?.filter,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<QueryPinnedActivitiesResponse>
+    >(
+      'POST',
+      '/api/v2/feeds/feed_groups/{feed_group_id}/feeds/{feed_id}/pinned_activities/query',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.QueryPinnedActivitiesResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
   async stopWatchingFeed(request: {
     feed_group_id: string;
     feed_id: string;

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

@@ -1713,6 +1713,13 @@ decoders.QueryModerationConfigsResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.QueryPinnedActivitiesResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    pinned_activities: { type: 'ActivityPinResponse', isSingle: false },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.QueryPollsResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     polls: { type: 'PollResponseData', isSingle: false },

package/src/gen/models/index.ts

@@ -4952,6 +4952,28 @@ export interface QueryModerationConfigsResponse {
   prev?: string;
 }
 
+export interface QueryPinnedActivitiesRequest {
+  limit?: number;
+
+  next?: string;
+
+  prev?: string;
+
+  sort?: SortParamRequest[];
+
+  filter?: Record<string, any>;
+}
+
+export interface QueryPinnedActivitiesResponse {
+  duration: string;
+
+  pinned_activities: ActivityPinResponse[];
+
+  next?: string;
+
+  prev?: string;
+}
+
 export interface QueryPollVotesRequest {
   limit?: number;