feat(llc): add support for OwnUser.blockedUserIds (#2168)

* feat(llc): add support for `OwnUser.blockedUserIds`

* chore: update CHANGELOG.md

* chore: update tests

* Update packages/stream_chat/lib/src/client/client.dart

Co-authored-by: Rene Floor <[email protected]>

* chore: add meta import

---------

Co-authored-by: Rene Floor <[email protected]>

Author: xsahil03x

packages/stream_chat/CHANGELOG.md

@@ -12,6 +12,11 @@
 
 - Added support for message moderation feature.
 
+- Improved user blocking functionality by updating client state when blocking/unblocking users:
+  - `client.blockUser` now updates `currentUser.blockedUserIds` list with newly blocked user IDs.
+  - `client.unblockUser` now removes the unblocked user ID from `currentUser.blockedUserIds` list.
+  - `client.queryBlockedUsers` now updates `currentUser.blockedUserIds` with the latest blocked users data.
+
 🐞 Fixed
 
 - [[#1964]](https://github.com/GetStream/stream-chat-flutter/issues/1964) Fixes `Channel.membership`

packages/stream_chat/lib/src/client/client.dart

@@ -2,6 +2,7 @@ import 'dart:async';
 
 import 'package:dio/dio.dart';
 import 'package:logging/logging.dart';
+import 'package:meta/meta.dart';
 import 'package:rxdart/rxdart.dart';
 import 'package:stream_chat/src/client/channel.dart';
 import 'package:stream_chat/src/client/retry_policy.dart';
@@ -1451,6 +1452,68 @@ class StreamChatClient {
         ...options,
       });
 
+  final _userBlockLock = Lock();
+
+  /// Blocks a user with the provided [userId].
+  Future<UserBlockResponse> blockUser(String userId) async {
+    try {
+      final response = await _userBlockLock.synchronized(
+        () => _chatApi.user.blockUser(userId),
+      );
+
+      final blockedUserId = response.blockedUserId;
+      final currentBlockedUserIds = [...?state.currentUser?.blockedUserIds];
+      if (!currentBlockedUserIds.contains(blockedUserId)) {
+        // Add the new blocked user to the blocked user list.
+        state.blockedUserIds = [...currentBlockedUserIds, blockedUserId];
+      }
+
+      return response;
+    } catch (e, stk) {
+      logger.severe('Error blocking user', e, stk);
+      rethrow;
+    }
+  }
+
+  /// Unblocks a previously blocked user with the provided [userId].
+  Future<EmptyResponse> unblockUser(String userId) async {
+    try {
+      final response = await _userBlockLock.synchronized(
+        () => _chatApi.user.unblockUser(userId),
+      );
+
+      final unblockedUserId = userId;
+      final currentBlockedUserIds = [...?state.currentUser?.blockedUserIds];
+      if (currentBlockedUserIds.contains(unblockedUserId)) {
+        // Remove the unblocked user from the blocked user list.
+        state.blockedUserIds = currentBlockedUserIds..remove(unblockedUserId);
+      }
+
+      return response;
+    } catch (e, stk) {
+      logger.severe('Error unblocking user', e, stk);
+      rethrow;
+    }
+  }
+
+  /// Retrieves a list of all users that the current user has blocked.
+  Future<BlockedUsersResponse> queryBlockedUsers() async {
+    try {
+      final response = await _userBlockLock.synchronized(
+        () => _chatApi.user.queryBlockedUsers(),
+      );
+
+      // Update the blocked user IDs with the latest data.
+      final blockedUserIds = response.blocks.map((it) => it.blockedUserId);
+      state.blockedUserIds = [...blockedUserIds.nonNulls];
+
+      return response;
+    } catch (e, stk) {
+      logger.severe('Error querying blocked users', e, stk);
+      rethrow;
+    }
+  }
+
   /// Mutes a user
   Future<EmptyResponse> muteUser(String userId) =>
       _chatApi.moderation.muteUser(userId);
@@ -1459,18 +1522,6 @@ class StreamChatClient {
   Future<EmptyResponse> unmuteUser(String userId) =>
       _chatApi.moderation.unmuteUser(userId);
 
-  /// Blocks a user
-  Future<UserBlockResponse> blockUser(String userId) =>
-      _chatApi.user.blockUser(userId);
-
-  /// Unblocks a user
-  Future<EmptyResponse> unblockUser(String userId) =>
-      _chatApi.user.unblockUser(userId);
-
-  /// Requests users with a given query.
-  Future<BlockedUsersResponse> queryBlockedUsers() =>
-      _chatApi.user.queryBlockedUsers();
-
   /// Flag a message
   Future<EmptyResponse> flagMessage(String messageId) =>
       _chatApi.moderation.flagMessage(messageId);
@@ -1997,6 +2048,11 @@ class ClientState {
     channels = channels..remove(channelCid);
   }
 
+  @visibleForTesting
+  set blockedUserIds(List<String> blockedUserIds) {
+    currentUser = currentUser?.copyWith(blockedUserIds: blockedUserIds);
+  }
+
   /// Used internally for optimistic update of unread count
   set totalUnreadCount(int unreadCount) {
     _totalUnreadCountController.add(unreadCount);

packages/stream_chat/lib/src/core/models/own_user.dart

@@ -17,6 +17,7 @@ class OwnUser extends User {
     this.unreadChannels = 0,
     this.channelMutes = const [],
     this.unreadThreads = 0,
+    this.blockedUserIds = const [],
     required super.id,
     super.role,
     super.name,
@@ -72,6 +73,7 @@ class OwnUser extends User {
     List<ChannelMute>? channelMutes,
     List<Device>? devices,
     List<Mute>? mutes,
+    List<String>? blockedUserIds,
     int? totalUnreadCount,
     int? unreadChannels,
     int? unreadThreads,
@@ -99,6 +101,7 @@ class OwnUser extends User {
         totalUnreadCount: totalUnreadCount ?? this.totalUnreadCount,
         unreadChannels: unreadChannels ?? this.unreadChannels,
         unreadThreads: unreadThreads ?? this.unreadThreads,
+        blockedUserIds: blockedUserIds ?? this.blockedUserIds,
         language: language ?? this.language,
       );
 
@@ -124,6 +127,7 @@ class OwnUser extends User {
       totalUnreadCount: other.totalUnreadCount,
       unreadChannels: other.unreadChannels,
       unreadThreads: other.unreadThreads,
+      blockedUserIds: other.blockedUserIds,
       updatedAt: other.updatedAt,
       language: other.language,
     );
@@ -153,6 +157,10 @@ class OwnUser extends User {
   @JsonKey(includeIfNull: false)
   final int unreadThreads;
 
+  /// List of user ids that are blocked by the user.
+  @JsonKey(includeIfNull: false)
+  final List<String> blockedUserIds;
+
   /// Known top level fields.
   ///
   /// Useful for [Serializer] methods.
@@ -163,6 +171,7 @@ class OwnUser extends User {
     'unread_channels',
     'channel_mutes',
     'unread_threads',
+    'blocked_user_ids',
     ...User.topLevelFields,
   ];
 }

packages/stream_chat/lib/src/core/models/own_user.g.dart

@@ -2294,6 +2294,167 @@ void main() {
       verifyNoMoreInteractions(api.user);
     });
 
+    group('Block user state management', () {
+      test('blockUser should update blockedUserIds on client state', () async {
+        final testUser = OwnUser(id: 'test-user');
+        const userId = 'blocked-user-id';
+
+        // Verify initial state
+        expect(client.state.currentUser?.blockedUserIds, isEmpty);
+
+        when(() => api.user.blockUser(userId)).thenAnswer(
+          (_) async => UserBlockResponse()
+            ..blockedUserId = userId
+            ..blockedByUserId = testUser.id
+            ..createdAt = DateTime.now(),
+        );
+
+        await client.blockUser(userId);
+
+        // Verify - should now include the blocked user ID
+        expect(client.state.currentUser?.blockedUserIds, contains(userId));
+        verify(() => api.user.blockUser(userId)).called(1);
+        verifyNoMoreInteractions(api.user);
+      });
+
+      test(
+        'blockUser should not duplicate existing blocked user IDs',
+        () async {
+          const userId = 'blocked-user-id';
+          client.state.blockedUserIds = const [userId];
+
+          // Verify the user is already in the blocked list
+          expect(client.state.currentUser?.blockedUserIds, contains(userId));
+
+          when(() => api.user.blockUser(userId)).thenAnswer(
+            (_) async => UserBlockResponse()
+              ..blockedUserId = userId
+              ..blockedByUserId = client.state.currentUser!.id
+              ..createdAt = DateTime.now(),
+          );
+
+          await client.blockUser(userId);
+
+          // Verify - should still have only one entry
+          expect(client.state.currentUser?.blockedUserIds, contains(userId));
+          expect(client.state.currentUser?.blockedUserIds.length, 1);
+          verify(() => api.user.blockUser(userId)).called(1);
+          verifyNoMoreInteractions(api.user);
+        },
+      );
+
+      test('unblockUser should remove user from blockedUserIds', () async {
+        const blockedUserId = 'blocked-user-id';
+        const otherBlockedId = 'other-blocked-id';
+        client.state.blockedUserIds = const [blockedUserId, otherBlockedId];
+
+        // Verify initial state includes both blocked IDs
+        expect(
+          client.state.currentUser?.blockedUserIds,
+          containsAll([blockedUserId, otherBlockedId]),
+        );
+
+        when(() => api.user.unblockUser(blockedUserId)).thenAnswer(
+          (_) async => EmptyResponse(),
+        );
+
+        await client.unblockUser(blockedUserId);
+
+        // Verify - blockedUserId should be removed
+        expect(
+          client.state.currentUser?.blockedUserIds,
+          contains(otherBlockedId),
+        );
+
+        expect(
+          client.state.currentUser?.blockedUserIds,
+          isNot(contains(blockedUserId)),
+        );
+
+        verify(() => api.user.unblockUser(blockedUserId)).called(1);
+        verifyNoMoreInteractions(api.user);
+      });
+
+      test(
+        'unblockUser should be resilient if user ID not in blocked list',
+        () async {
+          const nonBlockedUserId = 'not-in-list';
+          const otherBlockedId = 'other-blocked-id';
+          client.state.blockedUserIds = const [otherBlockedId];
+
+          // Verify initial state
+          expect(
+            client.state.currentUser?.blockedUserIds,
+            contains(otherBlockedId),
+          );
+
+          expect(
+            client.state.currentUser?.blockedUserIds,
+            isNot(contains(nonBlockedUserId)),
+          );
+
+          when(() => api.user.unblockUser(nonBlockedUserId)).thenAnswer(
+            (_) async => EmptyResponse(),
+          );
+
+          await client.unblockUser(nonBlockedUserId);
+
+          // Verify - should remain unchanged
+          expect(client.state.currentUser?.blockedUserIds,
+              contains(otherBlockedId));
+          expect(client.state.currentUser?.blockedUserIds,
+              isNot(contains(nonBlockedUserId)));
+          verify(() => api.user.unblockUser(nonBlockedUserId)).called(1);
+          verifyNoMoreInteractions(api.user);
+        },
+      );
+
+      test(
+        'queryBlockedUsers should update client state with blockedUserIds',
+        () async {
+          const blockedId1 = 'blocked-1';
+          const blockedId2 = 'blocked-2';
+
+          // Verify initial state
+          expect(client.state.currentUser?.blockedUserIds, isEmpty);
+
+          // Create mock users
+          final blockedUser1 = User(id: 'blocked-user-1');
+          final blockedUser2 = User(id: 'blocked-user-2');
+
+          // Mock the queryBlockedUsers API call
+          when(() => api.user.queryBlockedUsers()).thenAnswer(
+            (_) async => BlockedUsersResponse()
+              ..blocks = [
+                UserBlock(
+                  user: user,
+                  userId: user.id,
+                  blockedUser: blockedUser1,
+                  blockedUserId: blockedId1,
+                ),
+                UserBlock(
+                  user: user,
+                  userId: user.id,
+                  blockedUser: blockedUser2,
+                  blockedUserId: blockedId2,
+                ),
+              ],
+          );
+
+          await client.queryBlockedUsers();
+
+          // Verify - should now include both blocked IDs
+          expect(
+            client.state.currentUser?.blockedUserIds,
+            containsAll([blockedId1, blockedId2]),
+          );
+
+          verify(() => api.user.queryBlockedUsers()).called(1);
+          verifyNoMoreInteractions(api.user);
+        },
+      );
+    });
+
     test('`.shadowBan`', () async {
       const userId = 'test-user-id';