@stream-io/feeds-client 0.3.48 → 0.3.49

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

@@ -33,6 +33,8 @@ import type {
   UpdateCommentRequest,
   UpdateCommentResponse,
   UpdateFollowRequest,
+  UpdatePollPartialRequest,
+  UpdatePollRequest,
   UserRequest,
   WSEvent,
 } from '../gen/models';
@@ -452,15 +454,40 @@ 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 (

package/src/gen/feeds/FeedsApi.ts

@@ -775,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<

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

@@ -193,7 +193,7 @@ decoders.ActivityResponse = (input?: Record<string, any>) => {
 
     collections: { type: 'EnrichedCollectionResponse', isSingle: false },
 
-    reaction_groups: { type: 'ReactionGroupResponse', isSingle: false },
+    reaction_groups: { type: 'FeedsReactionGroupResponse', isSingle: false },
 
     user: { type: 'UserResponse', isSingle: true },
 
@@ -324,17 +324,15 @@ decoders.AppealItemResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.Ban = (input?: Record<string, any>) => {
+decoders.BanInfoResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
     expires: { type: 'DatetimeType', isSingle: true },
 
-    channel: { type: 'Channel', isSingle: true },
-
-    created_by: { type: 'User', isSingle: true },
+    created_by: { type: 'UserResponse', isSingle: true },
 
-    target: { type: 'User', isSingle: true },
+    user: { type: 'UserResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -496,44 +494,6 @@ decoders.CallSessionResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.Channel = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
-
-    updated_at: { type: 'DatetimeType', isSingle: true },
-
-    deleted_at: { type: 'DatetimeType', isSingle: true },
-
-    last_message_at: { type: 'DatetimeType', isSingle: true },
-
-    message_count_updated_at: { type: 'DatetimeType', isSingle: true },
-
-    active_live_locations: { type: 'SharedLocation', isSingle: false },
-
-    invites: { type: 'ChannelMember', isSingle: false },
-
-    members: { type: 'ChannelMember', isSingle: false },
-
-    config: { type: 'ChannelConfig', isSingle: true },
-
-    created_by: { type: 'User', isSingle: true },
-
-    members_lookup: { type: 'ChannelMemberLookup', isSingle: false },
-
-    truncated_by: { type: 'User', isSingle: true },
-  };
-  return decode(typeMappings, input);
-};
-
-decoders.ChannelConfig = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
-
-    updated_at: { type: 'DatetimeType', isSingle: true },
-  };
-  return decode(typeMappings, input);
-};
-
 decoders.ChannelConfigWithInfo = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -545,40 +505,6 @@ decoders.ChannelConfigWithInfo = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.ChannelMember = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
-
-    updated_at: { type: 'DatetimeType', isSingle: true },
-
-    archived_at: { type: 'DatetimeType', isSingle: true },
-
-    ban_expires: { type: 'DatetimeType', isSingle: true },
-
-    deleted_at: { type: 'DatetimeType', isSingle: true },
-
-    invite_accepted_at: { type: 'DatetimeType', isSingle: true },
-
-    invite_rejected_at: { type: 'DatetimeType', isSingle: true },
-
-    pinned_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'User', isSingle: true },
-  };
-  return decode(typeMappings, input);
-};
-
-decoders.ChannelMemberLookup = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    archived_at: { type: 'DatetimeType', isSingle: true },
-
-    ban_expires: { type: 'DatetimeType', isSingle: true },
-
-    pinned_at: { type: 'DatetimeType', isSingle: true },
-  };
-  return decode(typeMappings, input);
-};
-
 decoders.ChannelMemberResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -747,7 +673,7 @@ decoders.CommentResponse = (input?: Record<string, any>) => {
 
     latest_reactions: { type: 'FeedsReactionResponse', isSingle: false },
 
-    reaction_groups: { type: 'ReactionGroupResponse', isSingle: false },
+    reaction_groups: { type: 'FeedsReactionGroupResponse', isSingle: false },
   };
   return decode(typeMappings, input);
 };
@@ -834,13 +760,6 @@ decoders.DeleteCommentResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.Device = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
-  };
-  return decode(typeMappings, input);
-};
-
 decoders.DeviceResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1051,6 +970,15 @@ decoders.FeedUpdatedEvent = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.FeedsReactionGroupResponse = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    first_reaction_at: { type: 'DatetimeType', isSingle: true },
+
+    last_reaction_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.FeedsReactionResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1231,6 +1159,8 @@ decoders.HealthCheckEvent = (input?: Record<string, any>) => {
     created_at: { type: 'DatetimeType', isSingle: true },
 
     received_at: { type: 'DatetimeType', isSingle: true },
+
+    me: { type: 'OwnUserResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -1258,64 +1188,6 @@ decoders.MembershipLevelResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.Message = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
-
-    updated_at: { type: 'DatetimeType', isSingle: true },
-
-    latest_reactions: { type: 'Reaction', isSingle: false },
-
-    mentioned_users: { type: 'User', isSingle: false },
-
-    own_reactions: { type: 'Reaction', isSingle: false },
-
-    reaction_groups: { type: 'ReactionGroupResponse', isSingle: false },
-
-    deleted_at: { type: 'DatetimeType', isSingle: true },
-
-    message_text_updated_at: { type: 'DatetimeType', isSingle: true },
-
-    pin_expires: { type: 'DatetimeType', isSingle: true },
-
-    pinned_at: { type: 'DatetimeType', isSingle: true },
-
-    thread_participants: { type: 'User', isSingle: false },
-
-    member: { type: 'ChannelMember', isSingle: true },
-
-    pinned_by: { type: 'User', isSingle: true },
-
-    poll: { type: 'Poll', isSingle: true },
-
-    quoted_message: { type: 'Message', isSingle: true },
-
-    reminder: { type: 'MessageReminder', isSingle: true },
-
-    shared_location: { type: 'SharedLocation', isSingle: true },
-
-    user: { type: 'User', isSingle: true },
-  };
-  return decode(typeMappings, input);
-};
-
-decoders.MessageReminder = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
-
-    updated_at: { type: 'DatetimeType', isSingle: true },
-
-    remind_at: { type: 'DatetimeType', isSingle: true },
-
-    channel: { type: 'Channel', isSingle: true },
-
-    message: { type: 'Message', isSingle: true },
-
-    user: { type: 'User', isSingle: true },
-  };
-  return decode(typeMappings, input);
-};
-
 decoders.MessageResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1389,7 +1261,7 @@ decoders.ModerationFlaggedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    user: { type: 'User', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -1409,9 +1281,9 @@ decoders.ModerationMarkReviewedEvent = (input?: Record<string, any>) => {
 
 decoders.MuteResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    mutes: { type: 'UserMute', isSingle: false },
+    mutes: { type: 'UserMuteResponse', isSingle: false },
 
-    own_user: { type: 'OwnUser', isSingle: true },
+    own_user: { type: 'OwnUserResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -1448,7 +1320,7 @@ decoders.OwnBatchResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.OwnUser = (input?: Record<string, any>) => {
+decoders.OwnUserResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
@@ -1456,9 +1328,9 @@ decoders.OwnUser = (input?: Record<string, any>) => {
 
     channel_mutes: { type: 'ChannelMute', isSingle: false },
 
-    devices: { type: 'Device', isSingle: false },
+    devices: { type: 'DeviceResponse', isSingle: false },
 
-    mutes: { type: 'UserMute', isSingle: false },
+    mutes: { type: 'UserMuteResponse', isSingle: false },
 
     deactivated_at: { type: 'DatetimeType', isSingle: true },
 
@@ -1466,9 +1338,9 @@ decoders.OwnUser = (input?: Record<string, any>) => {
 
     last_active: { type: 'DatetimeType', isSingle: true },
 
-    last_engaged_at: { type: 'DatetimeType', isSingle: true },
+    revoke_tokens_issued_before: { type: 'DatetimeType', isSingle: true },
 
-    push_preferences: { type: 'PushPreferences', isSingle: true },
+    push_preferences: { type: 'PushPreferencesResponse', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -1482,21 +1354,6 @@ decoders.PinActivityResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.Poll = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
-
-    updated_at: { type: 'DatetimeType', isSingle: true },
-
-    latest_answers: { type: 'PollVote', isSingle: false },
-
-    own_votes: { type: 'PollVote', isSingle: false },
-
-    created_by: { type: 'User', isSingle: true },
-  };
-  return decode(typeMappings, input);
-};
-
 decoders.PollClosedFeedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1552,17 +1409,6 @@ decoders.PollUpdatedFeedEvent = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.PollVote = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
-
-    updated_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'User', isSingle: true },
-  };
-  return decode(typeMappings, input);
-};
-
 decoders.PollVoteCastedFeedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1629,7 +1475,7 @@ decoders.PollVotesResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.PushPreferences = (input?: Record<string, any>) => {
+decoders.PushPreferencesResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     disabled_until: { type: 'DatetimeType', isSingle: true },
   };
@@ -1741,8 +1587,6 @@ decoders.Reaction = (input?: Record<string, any>) => {
     updated_at: { type: 'DatetimeType', isSingle: true },
 
     deleted_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'User', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -1820,7 +1664,7 @@ decoders.ReviewQueueItemResponse = (input?: Record<string, any>) => {
 
     actions: { type: 'ActionLogResponse', isSingle: false },
 
-    bans: { type: 'Ban', isSingle: false },
+    bans: { type: 'BanInfoResponse', isSingle: false },
 
     flags: { type: 'ModerationFlagResponse', isSingle: false },
 
@@ -1849,21 +1693,6 @@ decoders.ReviewQueueItemResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.SharedLocation = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
-
-    updated_at: { type: 'DatetimeType', isSingle: true },
-
-    end_at: { type: 'DatetimeType', isSingle: true },
-
-    channel: { type: 'Channel', isSingle: true },
-
-    message: { type: 'Message', isSingle: true },
-  };
-  return decode(typeMappings, input);
-};
-
 decoders.SharedLocationResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
@@ -1956,7 +1785,7 @@ decoders.ThreadedCommentResponse = (input?: Record<string, any>) => {
 
     replies: { type: 'ThreadedCommentResponse', isSingle: false },
 
-    reaction_groups: { type: 'ReactionGroupResponse', isSingle: false },
+    reaction_groups: { type: 'FeedsReactionGroupResponse', isSingle: false },
   };
   return decode(typeMappings, input);
 };
@@ -2077,28 +1906,7 @@ decoders.UpsertConfigResponse = (input?: Record<string, any>) => {
 
 decoders.UpsertPushPreferencesResponse = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
-    user_preferences: { type: 'PushPreferences', isSingle: false },
-  };
-  return decode(typeMappings, input);
-};
-
-decoders.User = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    ban_expires: { type: 'DatetimeType', isSingle: true },
-
-    created_at: { type: 'DatetimeType', isSingle: true },
-
-    deactivated_at: { type: 'DatetimeType', isSingle: true },
-
-    deleted_at: { type: 'DatetimeType', isSingle: true },
-
-    last_active: { type: 'DatetimeType', isSingle: true },
-
-    last_engaged_at: { type: 'DatetimeType', isSingle: true },
-
-    revoke_tokens_issued_before: { type: 'DatetimeType', isSingle: true },
-
-    updated_at: { type: 'DatetimeType', isSingle: true },
+    user_preferences: { type: 'PushPreferencesResponse', isSingle: false },
   };
   return decode(typeMappings, input);
 };
@@ -2107,11 +1915,9 @@ decoders.UserBannedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    created_by: { type: 'User', isSingle: true },
-
     expiration: { type: 'DatetimeType', isSingle: true },
 
-    user: { type: 'User', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -2120,24 +1926,7 @@ decoders.UserDeactivatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    created_by: { type: 'User', isSingle: true },
-
-    user: { type: 'User', isSingle: true },
-  };
-  return decode(typeMappings, input);
-};
-
-decoders.UserMute = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
-
-    updated_at: { type: 'DatetimeType', isSingle: true },
-
-    expires: { type: 'DatetimeType', isSingle: true },
-
-    target: { type: 'User', isSingle: true },
-
-    user: { type: 'User', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -2157,20 +1946,11 @@ decoders.UserMuteResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
-decoders.UserMutedEvent = (input?: Record<string, any>) => {
-  const typeMappings: TypeMapping = {
-    created_at: { type: 'DatetimeType', isSingle: true },
-
-    user: { type: 'User', isSingle: true },
-  };
-  return decode(typeMappings, input);
-};
-
 decoders.UserReactivatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },
 
-    user: { type: 'User', isSingle: true },
+    received_at: { type: 'DatetimeType', isSingle: true },
   };
   return decode(typeMappings, input);
 };
@@ -2192,6 +1972,15 @@ decoders.UserResponse = (input?: Record<string, any>) => {
   return decode(typeMappings, input);
 };
 
+decoders.UserUnbannedEvent = (input?: Record<string, any>) => {
+  const typeMappings: TypeMapping = {
+    created_at: { type: 'DatetimeType', isSingle: true },
+
+    received_at: { type: 'DatetimeType', isSingle: true },
+  };
+  return decode(typeMappings, input);
+};
+
 decoders.UserUpdatedEvent = (input?: Record<string, any>) => {
   const typeMappings: TypeMapping = {
     created_at: { type: 'DatetimeType', isSingle: true },

package/src/gen/model-decoders/event-decoder-mapping.ts

@@ -150,11 +150,12 @@ const eventDecoderMapping: Record<
   'user.deactivated': (data: Record<string, any>) =>
     decoders.UserDeactivatedEvent(data),
 
-  'user.muted': (data: Record<string, any>) => decoders.UserMutedEvent(data),
-
   'user.reactivated': (data: Record<string, any>) =>
     decoders.UserReactivatedEvent(data),
 
+  'user.unbanned': (data: Record<string, any>) =>
+    decoders.UserUnbannedEvent(data),
+
   'user.updated': (data: Record<string, any>) =>
     decoders.UserUpdatedEvent(data),
 };