api: Handle typing events.

Signed-off-by: Zixuan James Li <[email protected]>

Author: PIG208

lib/api/model/events.dart

@@ -61,6 +61,7 @@ sealed class Event {
           case 'remove': return UpdateMessageFlagsRemoveEvent.fromJson(json);
           default: return UnexpectedEvent.fromJson(json);
         }
+      case 'typing': return TypingEvent.fromJson(json);
       case 'reaction': return ReactionEvent.fromJson(json);
       case 'heartbeat': return HeartbeatEvent.fromJson(json);
       // TODO add many more event types
@@ -715,8 +716,9 @@ class DeleteMessageEvent extends Event {
   Map<String, dynamic> toJson() => _$DeleteMessageEventToJson(this);
 }
 
-/// As in [DeleteMessageEvent.messageType]
-/// or [UpdateMessageFlagsMessageDetail.type].
+/// As in [DeleteMessageEvent.messageType],
+/// [UpdateMessageFlagsMessageDetail.type]
+/// or [TypingEvent.messageType]
 @JsonEnum(fieldRename: FieldRename.snake)
 enum MessageType {
   stream,
@@ -832,6 +834,68 @@ class UpdateMessageFlagsMessageDetail {
   Map<String, dynamic> toJson() => _$UpdateMessageFlagsMessageDetailToJson(this);
 }
 
+
+/// A Zulip event of type `typing`:
+///   https://zulip.com/api/get-events#typing-start
+///   https://zulip.com/api/get-events#typing-stop
+@JsonSerializable(fieldRename: FieldRename.snake)
+class TypingEvent extends Event {
+  @override
+  @JsonKey(includeToJson: true)
+  String get type => 'typing';
+
+  final TypingOp op;
+  final MessageType messageType;
+  @JsonKey(name: 'sender', readValue: _readSenderId)
+  final int senderId;
+  @JsonKey(name: 'recipients', fromJson: _recipientIdsFromJson)
+  final List<int>? recipientIds;
+  final int? streamId;
+  final String? topic;
+
+  TypingEvent({
+    required super.id,
+    required this.op,
+    required this.messageType,
+    required this.senderId,
+    required this.recipientIds,
+    required this.streamId,
+    required this.topic,
+  });
+
+  static dynamic _readSenderId(Map<dynamic, dynamic> json, String key) {
+    return json[key]['user_id'];
+  }
+
+  static List<int>? _recipientIdsFromJson(dynamic json) {
+    if (json == null) return null;
+    return (json as List<dynamic>).map((item) => item['user_id'] as int).toList();
+  }
+
+  factory TypingEvent.fromJson(Map<String, dynamic> json) {
+    final result = _$TypingEventFromJson(json);
+    // Crunchy-shell validation
+    switch (result.messageType) {
+      case MessageType.stream:
+        result.streamId as int;
+        result.topic as String;
+      case MessageType.private:
+        result.recipientIds as List<int>;
+    }
+    return result;
+  }
+
+  @override
+  Map<String, dynamic> toJson() => _$TypingEventToJson(this);
+}
+
+/// As in [TypingEvent.op].
+@JsonEnum(fieldRename: FieldRename.snake)
+enum TypingOp {
+  start,
+  stop
+}
+
 /// A Zulip event of type `reaction`, with op `add` or `remove`.
 ///
 /// See:

lib/api/model/events.g.dart

@@ -46,6 +46,14 @@ extension UpdateMessageEventChecks on Subject<UpdateMessageEvent> {
   Subject<bool?> get isMeMessage => has((e) => e.isMeMessage, 'isMeMessage');
 }
 
+extension TypingEventChecks on Subject<TypingEvent> {
+  Subject<MessageType> get messageType => has((e) => e.messageType, 'messageType');
+  Subject<int> get senderId => has((e) => e.senderId, 'senderId');
+  Subject<List<int>?> get recipientIds => has((e) => e.recipientIds, 'recipientIds');
+  Subject<int?> get streamId => has((e) => e.streamId, 'streamId');
+  Subject<String?> get topic => has((e) => e.topic, 'topic');
+}
+
 extension HeartbeatEventChecks on Subject<HeartbeatEvent> {
   // No properties not covered by Event.
 }

test/api/model/events_checks.dart

@@ -150,4 +150,53 @@ void main() {
       'message_details': {'123': {'type': 'private', 'mentioned': false, 'user_ids': [2]}},
     })).returnsNormally();
   });
+
+  group('typing status event', () {
+    final baseJson = {
+      'id': 1,
+      'type': 'typing',
+      'op': 'start',
+      'sender': {'user_id': 123, 'email': '[email protected]'},
+    };
+
+    test('direct message typing events', () {
+      final directMessageJson = {
+        ...baseJson,
+        'message_type': 'private',
+        'recipients': [1, 2, 3].map((e) => {'user_id': e, 'email': '$e@example.com'}).toList(),
+      };
+      check(TypingEvent.fromJson(directMessageJson))
+        ..recipientIds.isNotNull().deepEquals([1,2,3])
+        ..senderId.equals(123);
+      check(() => TypingEvent.fromJson(directMessageJson)).returnsNormally();
+      check(() => TypingEvent.fromJson({
+        ...directMessageJson, 'op': 'stop'})).returnsNormally();
+    });
+
+    test('private type missing recipient', () {
+      check(() => TypingEvent.fromJson({
+        ...baseJson, 'message_type': 'private'})).throws<void>();
+    });
+
+    test('stream message typing events', () {
+      final streamMessageJson = {
+        ...baseJson,
+        'message_type': 'stream',
+        'stream_id': 123,
+        'topic': 'foo',
+      };
+      check(() => TypingEvent.fromJson(streamMessageJson)).returnsNormally();
+      check(() => TypingEvent.fromJson({
+        ...streamMessageJson, 'op': 'stop'})).returnsNormally();
+    });
+
+    test('stream type missing streamId/topic', () {
+      check(() => TypingEvent.fromJson({
+        ...baseJson, 'message_type': 'stream'})).throws<void>();
+      check(() => TypingEvent.fromJson({
+        ...baseJson, 'message_type': 'stream', 'topic': 'foo'})).throws<void>();
+      check(() => TypingEvent.fromJson({
+        ...baseJson, 'message_type': 'stream', 'stream_id': 0})).throws<void>();
+    });
+  });
 }