@stream-io/feeds-client 0.3.48 → 0.3.50

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

@@ -188,6 +188,7 @@ export class Feed extends FeedApi {
     'feeds.feed.updated': handleFeedUpdated.bind(this),
     'feeds.feed_group.changed': Feed.noop,
     'feeds.feed_group.deleted': Feed.noop,
+    'feeds.feed_group.restored': Feed.noop,
     'feeds.follow.created': handleFollowCreated.bind(this),
     'feeds.follow.deleted': handleFollowDeleted.bind(this),
     'feeds.follow.updated': handleFollowUpdated.bind(this),
@@ -216,11 +217,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 +296,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 +512,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 +540,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

@@ -18,6 +18,8 @@ import type {
   AddCommentsBatchResponse,
   AddReactionRequest,
   AddReactionResponse,
+  AddUserGroupMembersRequest,
+  AddUserGroupMembersResponse,
   BlockUsersRequest,
   BlockUsersResponse,
   CastPollVoteRequest,
@@ -32,6 +34,8 @@ import type {
   CreateGuestResponse,
   CreatePollOptionRequest,
   CreatePollRequest,
+  CreateUserGroupRequest,
+  CreateUserGroupResponse,
   DeleteActivitiesRequest,
   DeleteActivitiesResponse,
   DeleteActivityReactionResponse,
@@ -57,10 +61,12 @@ import type {
   GetOGResponse,
   GetOrCreateFeedRequest,
   GetOrCreateFeedResponse,
+  GetUserGroupResponse,
   ImageUploadRequest,
   ImageUploadResponse,
   ListBlockListResponse,
   ListDevicesResponse,
+  ListUserGroupsResponse,
   MarkActivityRequest,
   OwnBatchRequest,
   OwnBatchResponse,
@@ -100,9 +106,11 @@ import type {
   RejectFeedMemberInviteResponse,
   RejectFollowRequest,
   RejectFollowResponse,
+  RemoveUserGroupMembersResponse,
   Response,
   RestoreActivityRequest,
   RestoreActivityResponse,
+  SearchUserGroupsResponse,
   SharedLocationResponse,
   SharedLocationsResponse,
   SingleFollowResponse,
@@ -136,6 +144,8 @@ import type {
   UpdatePollOptionRequest,
   UpdatePollPartialRequest,
   UpdatePollRequest,
+  UpdateUserGroupRequest,
+  UpdateUserGroupResponse,
   UpdateUsersPartialRequest,
   UpdateUsersRequest,
   UpdateUsersResponse,
@@ -775,6 +785,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<
@@ -935,8 +946,8 @@ export class FeedsApi {
     return { ...response.body, metadata: response.metadata };
   }
 
-  async readCollections(request: {
-    collection_refs: string[];
+  async readCollections(request?: {
+    collection_refs?: string[];
   }): Promise<StreamResponse<ReadCollectionsResponse>> {
     const queryParams = {
       collection_refs: request?.collection_refs,
@@ -2465,6 +2476,193 @@ export class FeedsApi {
     return { ...response.body, metadata: response.metadata };
   }
 
+  async listUserGroups(request?: {
+    limit?: number;
+    id_gt?: string;
+    created_at_gt?: string;
+    team_id?: string;
+  }): Promise<StreamResponse<ListUserGroupsResponse>> {
+    const queryParams = {
+      limit: request?.limit,
+      id_gt: request?.id_gt,
+      created_at_gt: request?.created_at_gt,
+      team_id: request?.team_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<ListUserGroupsResponse>
+    >('GET', '/api/v2/usergroups', undefined, queryParams);
+
+    decoders.ListUserGroupsResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async createUserGroup(
+    request: CreateUserGroupRequest,
+  ): Promise<StreamResponse<CreateUserGroupResponse>> {
+    const body = {
+      name: request?.name,
+      description: request?.description,
+      id: request?.id,
+      team_id: request?.team_id,
+      member_ids: request?.member_ids,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<CreateUserGroupResponse>
+    >(
+      'POST',
+      '/api/v2/usergroups',
+      undefined,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.CreateUserGroupResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async searchUserGroups(request: {
+    query: string;
+    limit?: number;
+    name_gt?: string;
+    id_gt?: string;
+    team_id?: string;
+  }): Promise<StreamResponse<SearchUserGroupsResponse>> {
+    const queryParams = {
+      query: request?.query,
+      limit: request?.limit,
+      name_gt: request?.name_gt,
+      id_gt: request?.id_gt,
+      team_id: request?.team_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<SearchUserGroupsResponse>
+    >('GET', '/api/v2/usergroups/search', undefined, queryParams);
+
+    decoders.SearchUserGroupsResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async deleteUserGroup(request: {
+    id: string;
+    team_id?: string;
+  }): Promise<StreamResponse<Response>> {
+    const queryParams = {
+      team_id: request?.team_id,
+    };
+    const pathParams = {
+      id: request?.id,
+    };
+
+    const response = await this.apiClient.sendRequest<StreamResponse<Response>>(
+      'DELETE',
+      '/api/v2/usergroups/{id}',
+      pathParams,
+      queryParams,
+    );
+
+    decoders.Response?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async getUserGroup(request: {
+    id: string;
+    team_id?: string;
+  }): Promise<StreamResponse<GetUserGroupResponse>> {
+    const queryParams = {
+      team_id: request?.team_id,
+    };
+    const pathParams = {
+      id: request?.id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<GetUserGroupResponse>
+    >('GET', '/api/v2/usergroups/{id}', pathParams, queryParams);
+
+    decoders.GetUserGroupResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async updateUserGroup(
+    request: UpdateUserGroupRequest & { id: string },
+  ): Promise<StreamResponse<UpdateUserGroupResponse>> {
+    const pathParams = {
+      id: request?.id,
+    };
+    const body = {
+      description: request?.description,
+      name: request?.name,
+      team_id: request?.team_id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<UpdateUserGroupResponse>
+    >(
+      'PUT',
+      '/api/v2/usergroups/{id}',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.UpdateUserGroupResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  async removeUserGroupMembers(request: {
+    id: string;
+  }): Promise<StreamResponse<RemoveUserGroupMembersResponse>> {
+    const pathParams = {
+      id: request?.id,
+    };
+
+    const response = await this.apiClient.sendRequest<
+      StreamResponse<RemoveUserGroupMembersResponse>
+    >('DELETE', '/api/v2/usergroups/{id}/members', pathParams, undefined);
+
+    decoders.RemoveUserGroupMembersResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
+  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<AddUserGroupMembersResponse>
+    >(
+      'POST',
+      '/api/v2/usergroups/{id}/members',
+      pathParams,
+      undefined,
+      body,
+      'application/json',
+    );
+
+    decoders.AddUserGroupMembersResponse?.(response.body);
+
+    return { ...response.body, metadata: response.metadata };
+  }
+
   async queryUsers(request?: {
     payload?: QueryUsersPayload;
   }): Promise<StreamResponse<QueryUsersResponse>> {