@stream-io/feeds-client 0.3.47 → 0.3.49

package/src/common/Poll.ts

@@ -3,38 +3,21 @@ import type { FeedsClient } from '../feeds-client';
 import type {
   PollVoteResponseData,
   QueryPollVotesRequest,
-  PollUpdatedFeedEvent,
-  WSEvent,
-  PollClosedFeedEvent,
-  PollVoteCastedFeedEvent,
-  PollVoteChangedFeedEvent,
-  PollVoteRemovedFeedEvent,
   PollResponseData,
 } from '../gen/models';
 
-const isPollUpdatedEvent = (
-  e: WSEvent,
-): e is { type: 'feeds.poll.updated' } & PollUpdatedFeedEvent =>
-  e.type === 'feeds.poll.updated';
-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 PollUpdatePayload = {
+  poll: PollResponseData;
+  created_at: Date;
+};
+
+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;
@@ -107,9 +90,16 @@ export class StreamPoll {
     return this.state.getLatestValue();
   }
 
-  public handlePollUpdated = (event: PollUpdatedFeedEvent) => {
+  public handlePollUpdated = (event: PollUpdatePayload) => {
     if (event.poll?.id && event.poll.id !== this.id) return;
-    if (!isPollUpdatedEvent(event as WSEvent)) return;
+    const currentState = this.data;
+    if (
+      currentState.updated_at &&
+      event.poll.updated_at &&
+      event.poll.updated_at <= currentState.updated_at
+    ) {
+      return;
+    }
     const { id, ...pollData } = event.poll;
     this.state.partialNext({
       ...pollData,
@@ -117,22 +107,32 @@ export class StreamPoll {
     });
   };
 
-  public handlePollClosed = (event: PollClosedFeedEvent) => {
+  public handlePollClosed = (event: PollUpdatePayload) => {
     if (event.poll?.id && event.poll.id !== this.id) return;
-    if (!isPollClosedEventEvent(event as WSEvent)) return;
+    const currentState = this.data;
+    if (currentState.is_closed) return;
     this.state.partialNext({
       is_closed: true,
       last_activity_at: new Date(event.created_at),
     });
   };
 
-  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;
     let ownVotesByOptionId = currentState.own_votes_by_option_id;
@@ -150,7 +150,10 @@ export class StreamPoll {
     }
 
     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,
@@ -176,14 +179,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;
@@ -249,13 +261,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/comment/handle-comment-added.ts

@@ -36,11 +36,23 @@ export function handleCommentAdded(
     }
 
     const newComments = entityState?.comments ? [...entityState.comments] : [];
+    const sort = entityState.pagination?.sort;
+    const hasMorePages = entityState.pagination?.next !== undefined;
+    const isFromCurrentUser = eventTriggeredByConnectedUser.call(this, payload);
 
-    if (entityState.pagination?.sort === 'last') {
+    if (sort === 'last') {
       newComments.unshift(comment);
+    } else if (sort === 'first') {
+      if (isFromCurrentUser) {
+        newComments.push(comment);
+      } else {
+        if (!hasMorePages) {
+          newComments.push(comment);
+        } else {
+          return currentState;
+        }
+      }
     } else {
-      // 'first' and other sort options
       newComments.push(comment);
     }
 

package/src/feed/feed.ts

@@ -216,11 +216,11 @@ export class Feed extends FeedApi {
     'app.updated': Feed.noop,
     'user.banned': Feed.noop,
     'user.deactivated': Feed.noop,
-    'user.muted': Feed.noop,
     'user.reactivated': Feed.noop,
     'user.updated': Feed.noop,
     'feeds.activity.feedback': handleActivityFeedback.bind(this),
     'feeds.activity.restored': Feed.noop,
+    'user.unbanned': Feed.noop,
   };
 
   protected eventDispatcher: EventDispatcher<WSEvent['type'], WSEvent> =
@@ -295,7 +295,9 @@ export class Feed extends FeedApi {
     const { last_get_or_create_request_config } = this.state.getLatestValue();
     if (last_get_or_create_request_config?.watch) {
       this.inProgressGetOrCreate = undefined;
-      await withRetry(() => this.getOrCreate(last_get_or_create_request_config));
+      await withRetry(() =>
+        this.getOrCreate(last_get_or_create_request_config),
+      );
     }
   }
 
@@ -509,6 +511,25 @@ export class Feed extends FeedApi {
         );
 
         const existingComments = newCommentsByEntityId[entityId]?.comments;
+        let comments: CommentResponse[] = existingComments
+          ? uniqueArrayMerge(
+              existingComments,
+              newComments,
+              (comment) => comment.id,
+            )
+          : newComments;
+        // Only sort when merging pages (existing + new); initial load order comes from API
+        if (
+          data.sort === 'first' &&
+          existingComments &&
+          existingComments.length > 0
+        ) {
+          comments = [...comments].sort(
+            (a, b) =>
+              new Date(a.created_at).getTime() -
+              new Date(b.created_at).getTime(),
+          );
+        }
 
         newCommentsByEntityId[entityId] = {
           ...newCommentsByEntityId[entityId],
@@ -518,13 +539,7 @@ export class Feed extends FeedApi {
             next: item.next,
             sort: data.sort,
           },
-          comments: existingComments
-            ? uniqueArrayMerge(
-                existingComments,
-                newComments,
-                (comment) => comment.id,
-              )
-            : newComments,
+          comments,
         };
       }
 

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,
@@ -31,6 +33,8 @@ import type {
   UpdateCommentRequest,
   UpdateCommentResponse,
   UpdateFollowRequest,
+  UpdatePollPartialRequest,
+  UpdatePollRequest,
   UserRequest,
   WSEvent,
 } from '../gen/models';
@@ -450,15 +454,80 @@ export class FeedsClient extends FeedsApi {
     return streamDevToken(userId);
   };
 
+  updatePoll = async (request: UpdatePollRequest) => {
+    const poll = this.pollFromState(request.id);
+    const response = await super.updatePoll(request);
+    if (response.poll && poll) {
+      poll.handlePollUpdated({ poll: response.poll, created_at: new Date() });
+    }
+    return response;
+  };
+
+  updatePollPartial = async (
+    request: UpdatePollPartialRequest & { poll_id: string },
+  ) => {
+    const poll = this.pollFromState(request.poll_id);
+    const response = await super.updatePollPartial(request);
+    if (response.poll && poll) {
+      poll.handlePollUpdated({ poll: response.poll, created_at: new Date() });
+    }
+    return response;
+  };
+
   closePoll = async (request: {
     poll_id: string;
   }): Promise<StreamResponse<PollResponse>> => {
-    return await this.updatePollPartial({
+    const poll = this.pollFromState(request.poll_id);
+    const response = await super.updatePollPartial({
       poll_id: request.poll_id,
       set: {
         is_closed: true,
       },
     });
+    if (response.poll && poll) {
+      poll.handlePollClosed({ poll: response.poll, created_at: new Date() });
+    }
+    return response;
+  };
+
+  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 = (

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,
@@ -773,6 +775,7 @@ export class FeedsApi {
       mentioned_user_ids: request?.mentioned_user_ids,
       custom: request?.custom,
       location: request?.location,
+      search_data: request?.search_data,
     };
 
     const response = await this.apiClient.sendRequest<
@@ -1611,6 +1614,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;