feat(persistence): add pinned message reactions table

packages/stream_chat_persistence/lib/src/dao/dao.dart

@@ -4,6 +4,7 @@ export 'connection_event_dao.dart';
 export 'member_dao.dart';
 export 'message_dao.dart';
 export 'pinned_message_dao.dart';
+export 'pinned_message_reaction_dao.dart';
 export 'reaction_dao.dart';
 export 'read_dao.dart';
 export 'user_dao.dart';

packages/stream_chat_persistence/lib/src/dao/pinned_message_dao.dart

@@ -39,8 +39,10 @@ class PinnedMessageDao extends DatabaseAccessor<MoorChatDatabase>
     final userEntity = rows.readTableOrNull(users);
     final pinnedByEntity = rows.readTableOrNull(_pinnedByUsers);
     final msgEntity = rows.readTable(pinnedMessages);
-    final latestReactions = await _db.reactionDao.getReactions(msgEntity.id);
-    final ownReactions = await _db.reactionDao.getReactionsByUserId(
+    final latestReactions =
+        await _db.pinnedMessageReactionDao.getReactions(msgEntity.id);
+    final ownReactions =
+        await _db.pinnedMessageReactionDao.getReactionsByUserId(
       msgEntity.id,
       _db.userId,
     );

packages/stream_chat_persistence/lib/src/dao/pinned_message_reaction_dao.dart

@@ -0,0 +1,60 @@
+import 'package:moor/moor.dart';
+import 'package:stream_chat/stream_chat.dart';
+import 'package:stream_chat_persistence/src/db/moor_chat_database.dart';
+import 'package:stream_chat_persistence/src/entity/pinned_message_reactions.dart';
+import 'package:stream_chat_persistence/src/entity/users.dart';
+import 'package:stream_chat_persistence/src/mapper/mapper.dart';
+
+part 'pinned_message_reaction_dao.g.dart';
+
+/// The Data Access Object for operations in [PinnedMessageReactions] table.
+@UseDao(tables: [PinnedMessageReactions, Users])
+class PinnedMessageReactionDao extends DatabaseAccessor<MoorChatDatabase>
+    with _$PinnedMessageReactionDaoMixin {
+  /// Creates a new reaction dao instance
+  PinnedMessageReactionDao(MoorChatDatabase db) : super(db);
+
+  /// Returns all the reactions of a particular message by matching
+  /// [Reactions.messageId] with [messageId]
+  Future<List<Reaction>> getReactions(String messageId) =>
+      (select(pinnedMessageReactions).join([
+        leftOuterJoin(users, pinnedMessageReactions.userId.equalsExp(users.id)),
+      ])
+            ..where(pinnedMessageReactions.messageId.equals(messageId))
+            ..orderBy([OrderingTerm.asc(pinnedMessageReactions.createdAt)]))
+          .map((rows) {
+        final userEntity = rows.readTableOrNull(users);
+        final reactionEntity = rows.readTable(pinnedMessageReactions);
+        return reactionEntity.toReaction(user: userEntity?.toUser());
+      }).get();
+
+  /// Returns all the reactions of a particular message
+  /// added by a particular user by matching
+  /// [Reactions.messageId] with [messageId] and
+  /// [Reactions.userId] with [userId]
+  Future<List<Reaction>> getReactionsByUserId(
+    String messageId,
+    String userId,
+  ) async {
+    final reactions = await getReactions(messageId);
+    return reactions.where((it) => it.userId == userId).toList();
+  }
+
+  /// Updates the reactions data with the new [reactionList] data
+  Future<void> updateReactions(List<Reaction> reactionList) => batch((it) {
+        it.insertAllOnConflictUpdate(
+          pinnedMessageReactions,
+          reactionList.map((r) => r.toPinnedEntity()).toList(),
+        );
+      });
+
+  /// Deletes all the reactions whose [Reactions.messageId] is
+  /// present in [messageIds]
+  Future<void> deleteReactionsByMessageIds(List<String> messageIds) =>
+      batch((it) {
+        it.deleteWhere<PinnedMessageReactions, PinnedMessageReactionEntity>(
+          pinnedMessageReactions,
+          (r) => r.messageId.isIn(messageIds),
+        );
+      });
+}

packages/stream_chat_persistence/lib/src/dao/pinned_message_reaction_dao.g.dart

@@ -0,0 +1,13 @@
+// GENERATED CODE - DO NOT MODIFY BY HAND
+
+part of 'pinned_message_reaction_dao.dart';
+
+// **************************************************************************
+// DaoGenerator
+// **************************************************************************
+
+mixin _$PinnedMessageReactionDaoMixin on DatabaseAccessor<MoorChatDatabase> {
+  $PinnedMessageReactionsTable get pinnedMessageReactions =>
+      attachedDatabase.pinnedMessageReactions;
+  $UsersTable get users => attachedDatabase.users;
+}

packages/stream_chat_persistence/lib/src/db/moor_chat_database.dart

@@ -14,6 +14,7 @@ part 'moor_chat_database.g.dart';
   Channels,
   Messages,
   PinnedMessages,
+  PinnedMessageReactions,
   Reactions,
   Users,
   Members,
@@ -25,6 +26,7 @@ part 'moor_chat_database.g.dart';
   ChannelDao,
   MessageDao,
   PinnedMessageDao,
+  PinnedMessageReactionDao,
   MemberDao,
   ReactionDao,
   ReadDao,

packages/stream_chat_persistence/lib/src/db/moor_chat_database.g.dart

@@ -2769,6 +2769,340 @@ class $PinnedMessagesTable extends PinnedMessages
       MapConverter<Object?>();
 }
 
+class PinnedMessageReactionEntity extends DataClass
+    implements Insertable<PinnedMessageReactionEntity> {
+  /// The id of the user that sent the reaction
+  final String userId;
+
+  /// The messageId to which the reaction belongs
+  final String messageId;
+
+  /// The type of the reaction
+  final String type;
+
+  /// The DateTime on which the reaction is created
+  final DateTime createdAt;
+
+  /// The score of the reaction (ie. number of reactions sent)
+  final int score;
+
+  /// Reaction custom extraData
+  final Map<String, Object?>? extraData;
+  PinnedMessageReactionEntity(
+      {required this.userId,
+      required this.messageId,
+      required this.type,
+      required this.createdAt,
+      required this.score,
+      this.extraData});
+  factory PinnedMessageReactionEntity.fromData(
+      Map<String, dynamic> data, GeneratedDatabase db,
+      {String? prefix}) {
+    final effectivePrefix = prefix ?? '';
+    return PinnedMessageReactionEntity(
+      userId: const StringType()
+          .mapFromDatabaseResponse(data['${effectivePrefix}user_id'])!,
+      messageId: const StringType()
+          .mapFromDatabaseResponse(data['${effectivePrefix}message_id'])!,
+      type: const StringType()
+          .mapFromDatabaseResponse(data['${effectivePrefix}type'])!,
+      createdAt: const DateTimeType()
+          .mapFromDatabaseResponse(data['${effectivePrefix}created_at'])!,
+      score: const IntType()
+          .mapFromDatabaseResponse(data['${effectivePrefix}score'])!,
+      extraData: $PinnedMessageReactionsTable.$converter0.mapToDart(
+          const StringType()
+              .mapFromDatabaseResponse(data['${effectivePrefix}extra_data'])),
+    );
+  }
+  @override
+  Map<String, Expression> toColumns(bool nullToAbsent) {
+    final map = <String, Expression>{};
+    map['user_id'] = Variable<String>(userId);
+    map['message_id'] = Variable<String>(messageId);
+    map['type'] = Variable<String>(type);
+    map['created_at'] = Variable<DateTime>(createdAt);
+    map['score'] = Variable<int>(score);
+    if (!nullToAbsent || extraData != null) {
+      final converter = $PinnedMessageReactionsTable.$converter0;
+      map['extra_data'] = Variable<String?>(converter.mapToSql(extraData));
+    }
+    return map;
+  }
+
+  factory PinnedMessageReactionEntity.fromJson(Map<String, dynamic> json,
+      {ValueSerializer? serializer}) {
+    serializer ??= moorRuntimeOptions.defaultSerializer;
+    return PinnedMessageReactionEntity(
+      userId: serializer.fromJson<String>(json['userId']),
+      messageId: serializer.fromJson<String>(json['messageId']),
+      type: serializer.fromJson<String>(json['type']),
+      createdAt: serializer.fromJson<DateTime>(json['createdAt']),
+      score: serializer.fromJson<int>(json['score']),
+      extraData: serializer.fromJson<Map<String, Object?>?>(json['extraData']),
+    );
+  }
+  @override
+  Map<String, dynamic> toJson({ValueSerializer? serializer}) {
+    serializer ??= moorRuntimeOptions.defaultSerializer;
+    return <String, dynamic>{
+      'userId': serializer.toJson<String>(userId),
+      'messageId': serializer.toJson<String>(messageId),
+      'type': serializer.toJson<String>(type),
+      'createdAt': serializer.toJson<DateTime>(createdAt),
+      'score': serializer.toJson<int>(score),
+      'extraData': serializer.toJson<Map<String, Object?>?>(extraData),
+    };
+  }
+
+  PinnedMessageReactionEntity copyWith(
+          {String? userId,
+          String? messageId,
+          String? type,
+          DateTime? createdAt,
+          int? score,
+          Value<Map<String, Object?>?> extraData = const Value.absent()}) =>
+      PinnedMessageReactionEntity(
+        userId: userId ?? this.userId,
+        messageId: messageId ?? this.messageId,
+        type: type ?? this.type,
+        createdAt: createdAt ?? this.createdAt,
+        score: score ?? this.score,
+        extraData: extraData.present ? extraData.value : this.extraData,
+      );
+  @override
+  String toString() {
+    return (StringBuffer('PinnedMessageReactionEntity(')
+          ..write('userId: $userId, ')
+          ..write('messageId: $messageId, ')
+          ..write('type: $type, ')
+          ..write('createdAt: $createdAt, ')
+          ..write('score: $score, ')
+          ..write('extraData: $extraData')
+          ..write(')'))
+        .toString();
+  }
+
+  @override
+  int get hashCode => $mrjf($mrjc(
+      userId.hashCode,
+      $mrjc(
+          messageId.hashCode,
+          $mrjc(
+              type.hashCode,
+              $mrjc(createdAt.hashCode,
+                  $mrjc(score.hashCode, extraData.hashCode))))));
+  @override
+  bool operator ==(Object other) =>
+      identical(this, other) ||
+      (other is PinnedMessageReactionEntity &&
+          other.userId == this.userId &&
+          other.messageId == this.messageId &&
+          other.type == this.type &&
+          other.createdAt == this.createdAt &&
+          other.score == this.score &&
+          other.extraData == this.extraData);
+}
+
+class PinnedMessageReactionsCompanion
+    extends UpdateCompanion<PinnedMessageReactionEntity> {
+  final Value<String> userId;
+  final Value<String> messageId;
+  final Value<String> type;
+  final Value<DateTime> createdAt;
+  final Value<int> score;
+  final Value<Map<String, Object?>?> extraData;
+  const PinnedMessageReactionsCompanion({
+    this.userId = const Value.absent(),
+    this.messageId = const Value.absent(),
+    this.type = const Value.absent(),
+    this.createdAt = const Value.absent(),
+    this.score = const Value.absent(),
+    this.extraData = const Value.absent(),
+  });
+  PinnedMessageReactionsCompanion.insert({
+    required String userId,
+    required String messageId,
+    required String type,
+    this.createdAt = const Value.absent(),
+    this.score = const Value.absent(),
+    this.extraData = const Value.absent(),
+  })  : userId = Value(userId),
+        messageId = Value(messageId),
+        type = Value(type);
+  static Insertable<PinnedMessageReactionEntity> custom({
+    Expression<String>? userId,
+    Expression<String>? messageId,
+    Expression<String>? type,
+    Expression<DateTime>? createdAt,
+    Expression<int>? score,
+    Expression<Map<String, Object?>?>? extraData,
+  }) {
+    return RawValuesInsertable({
+      if (userId != null) 'user_id': userId,
+      if (messageId != null) 'message_id': messageId,
+      if (type != null) 'type': type,
+      if (createdAt != null) 'created_at': createdAt,
+      if (score != null) 'score': score,
+      if (extraData != null) 'extra_data': extraData,
+    });
+  }
+
+  PinnedMessageReactionsCompanion copyWith(
+      {Value<String>? userId,
+      Value<String>? messageId,
+      Value<String>? type,
+      Value<DateTime>? createdAt,
+      Value<int>? score,
+      Value<Map<String, Object?>?>? extraData}) {
+    return PinnedMessageReactionsCompanion(
+      userId: userId ?? this.userId,
+      messageId: messageId ?? this.messageId,
+      type: type ?? this.type,
+      createdAt: createdAt ?? this.createdAt,
+      score: score ?? this.score,
+      extraData: extraData ?? this.extraData,
+    );
+  }
+
+  @override
+  Map<String, Expression> toColumns(bool nullToAbsent) {
+    final map = <String, Expression>{};
+    if (userId.present) {
+      map['user_id'] = Variable<String>(userId.value);
+    }
+    if (messageId.present) {
+      map['message_id'] = Variable<String>(messageId.value);
+    }
+    if (type.present) {
+      map['type'] = Variable<String>(type.value);
+    }
+    if (createdAt.present) {
+      map['created_at'] = Variable<DateTime>(createdAt.value);
+    }
+    if (score.present) {
+      map['score'] = Variable<int>(score.value);
+    }
+    if (extraData.present) {
+      final converter = $PinnedMessageReactionsTable.$converter0;
+      map['extra_data'] =
+          Variable<String?>(converter.mapToSql(extraData.value));
+    }
+    return map;
+  }
+
+  @override
+  String toString() {
+    return (StringBuffer('PinnedMessageReactionsCompanion(')
+          ..write('userId: $userId, ')
+          ..write('messageId: $messageId, ')
+          ..write('type: $type, ')
+          ..write('createdAt: $createdAt, ')
+          ..write('score: $score, ')
+          ..write('extraData: $extraData')
+          ..write(')'))
+        .toString();
+  }
+}
+
+class $PinnedMessageReactionsTable extends PinnedMessageReactions
+    with TableInfo<$PinnedMessageReactionsTable, PinnedMessageReactionEntity> {
+  final GeneratedDatabase _db;
+  final String? _alias;
+  $PinnedMessageReactionsTable(this._db, [this._alias]);
+  final VerificationMeta _userIdMeta = const VerificationMeta('userId');
+  late final GeneratedColumn<String?> userId = GeneratedColumn<String?>(
+      'user_id', aliasedName, false,
+      typeName: 'TEXT', requiredDuringInsert: true);
+  final VerificationMeta _messageIdMeta = const VerificationMeta('messageId');
+  late final GeneratedColumn<String?> messageId = GeneratedColumn<String?>(
+      'message_id', aliasedName, false,
+      typeName: 'TEXT',
+      requiredDuringInsert: true,
+      $customConstraints: 'REFERENCES pinned_messages(id) ON DELETE CASCADE');
+  final VerificationMeta _typeMeta = const VerificationMeta('type');
+  late final GeneratedColumn<String?> type = GeneratedColumn<String?>(
+      'type', aliasedName, false,
+      typeName: 'TEXT', requiredDuringInsert: true);
+  final VerificationMeta _createdAtMeta = const VerificationMeta('createdAt');
+  late final GeneratedColumn<DateTime?> createdAt = GeneratedColumn<DateTime?>(
+      'created_at', aliasedName, false,
+      typeName: 'INTEGER',
+      requiredDuringInsert: false,
+      defaultValue: currentDateAndTime);
+  final VerificationMeta _scoreMeta = const VerificationMeta('score');
+  late final GeneratedColumn<int?> score = GeneratedColumn<int?>(
+      'score', aliasedName, false,
+      typeName: 'INTEGER',
+      requiredDuringInsert: false,
+      defaultValue: const Constant(0));
+  final VerificationMeta _extraDataMeta = const VerificationMeta('extraData');
+  late final GeneratedColumnWithTypeConverter<Map<String, Object?>, String?>
+      extraData = GeneratedColumn<String?>('extra_data', aliasedName, true,
+              typeName: 'TEXT', requiredDuringInsert: false)
+          .withConverter<Map<String, Object?>>(
+              $PinnedMessageReactionsTable.$converter0);
+  @override
+  List<GeneratedColumn> get $columns =>
+      [userId, messageId, type, createdAt, score, extraData];
+  @override
+  String get aliasedName => _alias ?? 'pinned_message_reactions';
+  @override
+  String get actualTableName => 'pinned_message_reactions';
+  @override
+  VerificationContext validateIntegrity(
+      Insertable<PinnedMessageReactionEntity> instance,
+      {bool isInserting = false}) {
+    final context = VerificationContext();
+    final data = instance.toColumns(true);
+    if (data.containsKey('user_id')) {
+      context.handle(_userIdMeta,
+          userId.isAcceptableOrUnknown(data['user_id']!, _userIdMeta));
+    } else if (isInserting) {
+      context.missing(_userIdMeta);
+    }
+    if (data.containsKey('message_id')) {
+      context.handle(_messageIdMeta,
+          messageId.isAcceptableOrUnknown(data['message_id']!, _messageIdMeta));
+    } else if (isInserting) {
+      context.missing(_messageIdMeta);
+    }
+    if (data.containsKey('type')) {
+      context.handle(
+          _typeMeta, type.isAcceptableOrUnknown(data['type']!, _typeMeta));
+    } else if (isInserting) {
+      context.missing(_typeMeta);
+    }
+    if (data.containsKey('created_at')) {
+      context.handle(_createdAtMeta,
+          createdAt.isAcceptableOrUnknown(data['created_at']!, _createdAtMeta));
+    }
+    if (data.containsKey('score')) {
+      context.handle(
+          _scoreMeta, score.isAcceptableOrUnknown(data['score']!, _scoreMeta));
+    }
+    context.handle(_extraDataMeta, const VerificationResult.success());
+    return context;
+  }
+
+  @override
+  Set<GeneratedColumn> get $primaryKey => {messageId, type, userId};
+  @override
+  PinnedMessageReactionEntity map(Map<String, dynamic> data,
+      {String? tablePrefix}) {
+    return PinnedMessageReactionEntity.fromData(data, _db,
+        prefix: tablePrefix != null ? '$tablePrefix.' : null);
+  }
+
+  @override
+  $PinnedMessageReactionsTable createAlias(String alias) {
+    return $PinnedMessageReactionsTable(_db, alias);
+  }
+
+  static TypeConverter<Map<String, Object?>, String> $converter0 =
+      MapConverter<Object?>();
+}
+
 class ReactionEntity extends DataClass implements Insertable<ReactionEntity> {
   /// The id of the user that sent the reaction
   final String userId;
@@ -4897,6 +5231,8 @@ abstract class _$MoorChatDatabase extends GeneratedDatabase {
   late final $ChannelsTable channels = $ChannelsTable(this);
   late final $MessagesTable messages = $MessagesTable(this);
   late final $PinnedMessagesTable pinnedMessages = $PinnedMessagesTable(this);
+  late final $PinnedMessageReactionsTable pinnedMessageReactions =
+      $PinnedMessageReactionsTable(this);
   late final $ReactionsTable reactions = $ReactionsTable(this);
   late final $UsersTable users = $UsersTable(this);
   late final $MembersTable members = $MembersTable(this);
@@ -4909,6 +5245,8 @@ abstract class _$MoorChatDatabase extends GeneratedDatabase {
   late final MessageDao messageDao = MessageDao(this as MoorChatDatabase);
   late final PinnedMessageDao pinnedMessageDao =
       PinnedMessageDao(this as MoorChatDatabase);
+  late final PinnedMessageReactionDao pinnedMessageReactionDao =
+      PinnedMessageReactionDao(this as MoorChatDatabase);
   late final MemberDao memberDao = MemberDao(this as MoorChatDatabase);
   late final ReactionDao reactionDao = ReactionDao(this as MoorChatDatabase);
   late final ReadDao readDao = ReadDao(this as MoorChatDatabase);
@@ -4923,6 +5261,7 @@ abstract class _$MoorChatDatabase extends GeneratedDatabase {
         channels,
         messages,
         pinnedMessages,
+        pinnedMessageReactions,
         reactions,
         users,
         members,

packages/stream_chat_persistence/lib/src/entity/entity.dart

@@ -3,6 +3,7 @@ export 'channels.dart';
 export 'connection_events.dart';
 export 'members.dart';
 export 'messages.dart';
+export 'pinned_message_reactions.dart';
 export 'pinned_messages.dart';
 export 'reactions.dart';
 export 'reads.dart';

packages/stream_chat_persistence/lib/src/entity/pinned_message_reactions.dart

@@ -0,0 +1,13 @@
+// coverage:ignore-file
+import 'package:moor/moor.dart';
+
+import 'package:stream_chat_persistence/src/entity/reactions.dart';
+
+/// Represents a [PinnedMessageReactions] table in [MoorChatDatabase].
+@DataClassName('PinnedMessageReactionEntity')
+class PinnedMessageReactions extends Reactions {
+  /// The messageId to which the reaction belongs
+  @override
+  TextColumn get messageId => text()
+      .customConstraint('REFERENCES pinned_messages(id) ON DELETE CASCADE')();
+}

packages/stream_chat_persistence/lib/src/mapper/mapper.dart

@@ -3,6 +3,7 @@ export 'event_mapper.dart';
 export 'member_mapper.dart';
 export 'message_mapper.dart';
 export 'pinned_message_mapper.dart';
+export 'pinned_message_reaction_mapper.dart';
 export 'reaction_mapper.dart';
 export 'read_mapper.dart';
 export 'user_mapper.dart';

packages/stream_chat_persistence/lib/src/mapper/pinned_message_reaction_mapper.dart

@@ -0,0 +1,29 @@
+import 'package:stream_chat/stream_chat.dart';
+import 'package:stream_chat_persistence/src/db/moor_chat_database.dart';
+
+/// Useful mapping functions for [PinnedMessageReactionEntity]
+extension PinnedMessageReactionEntityX on PinnedMessageReactionEntity {
+  /// Maps a [PinnedMessageReactionEntity] into [Reaction]
+  Reaction toReaction({User? user}) => Reaction(
+        extraData: extraData ?? {},
+        type: type,
+        createdAt: createdAt,
+        userId: userId,
+        user: user,
+        messageId: messageId,
+        score: score,
+      );
+}
+
+/// Useful mapping functions for [Reaction]
+extension PReactionX on Reaction {
+  /// Maps a [Reaction] into [ReactionEntity]
+  PinnedMessageReactionEntity toPinnedEntity() => PinnedMessageReactionEntity(
+        extraData: extraData,
+        type: type,
+        createdAt: createdAt,
+        userId: userId!,
+        messageId: messageId!,
+        score: score,
+      );
+}

packages/stream_chat_persistence/lib/src/stream_chat_persistence_client.dart

@@ -318,6 +318,15 @@ class StreamChatPersistenceClient extends ChatPersistenceClient {
     );
   }
 
+  @override
+  Future<void> updatePinnedMessageReactions(List<Reaction> reactions) {
+    assert(_debugIsConnected, '');
+    _logger.info('updatePinnedMessageReactions');
+    return _readProtected(
+      () => db!.pinnedMessageReactionDao.updateReactions(reactions),
+    );
+  }
+
   @override
   Future<void> updateReactions(List<Reaction> reactions) {
     assert(_debugIsConnected, '');
@@ -339,6 +348,18 @@ class StreamChatPersistenceClient extends ChatPersistenceClient {
     return _readProtected(() => db!.userDao.updateUsers(users));
   }
 
+  @override
+  Future<void> deletePinnedMessageReactionsByMessageId(
+    List<String> messageIds,
+  ) {
+    assert(_debugIsConnected, '');
+    _logger.info('deletePinnedMessageReactionsByMessageId');
+    return _readProtected(
+      () =>
+          db!.pinnedMessageReactionDao.deleteReactionsByMessageIds(messageIds),
+    );
+  }
+
   @override
   Future<void> deleteReactionsByMessageId(List<String> messageIds) {
     assert(_debugIsConnected, '');