Server-Sent Events

import 'package:revali_router/revali_router.dart';

@Controller('events')
class EventController {
  const EventController();

  @SSE('updates')
  Stream<String> sendUpdates() async* {
    yield 'Hello, world!';
    yield 'This is a real-time update';
  }
}

@SSE('limited')
Stream<String> sendLimitedData() async* {
  for (int i = 0; i < 5; i++) {
    yield 'Update $i';
    await Future.delayed(const Duration(seconds: 1));
  }
  // Connection closes automatically after 5 messages
}

@SSE('events')
Stream<String> sendEvents(CleanUp cleanUp) async* {
  // Register cleanup callback
  cleanUp.add(() {
    print('Connection closed, cleaning up resources');
    resourceService.dispose();
  });

  // Stream data
  yield* eventService.stream;
}

@SSE('live')
Stream<String> sendLiveUpdates() async* {
  // This stream never ends, connection stays open
  await for (final update in liveUpdateService.stream) {
    yield update;
  }
}

import 'dart:io';
import 'dart:convert';

void main() async {
  final http = HttpClient();

  try {
    final request = await http.getUrl(Uri.parse('http://localhost:8080/events/updates'));
    final response = await request.close();

    if (response.statusCode == 200) {
      final stream = response.transform(utf8.decoder);

      await for (final event in stream) {
        print('Received: $event');
      }
    }
  } catch (e) {
    print('Error: $e');
  } finally {
    http.close();
  }
}

@SSE('events')
Stream<String> sendEvents() async* {
  try {
    yield* eventService.stream;
  } catch (e) {
    yield 'Error: $e';
    // Connection will close after error
  }
}

@SSE('events')
Stream<String> sendEvents() async* {
  try {
    yield* eventService.stream;
  } catch (e) {
    yield 'Service temporarily unavailable';
    await Future.delayed(const Duration(seconds: 5));

    // Try to reconnect
    yield* sendEvents();
  }
}

// ✅ Good - Use objects with toJson for complex data
class StatusUpdate {
  const StatusUpdate({required this.status, required this.timestamp});
  final String status;
  final DateTime timestamp;

  Map<String, dynamic> toJson() {
    return {
      'status': status,
      'timestamp': timestamp.toIso8601String(),
    };
  }
}

@SSE('status')
Stream<StatusUpdate> sendStatus() async* {
  yield StatusUpdate(status: 'Running', timestamp: DateTime.now());
}

// ❌ Avoid - Complex objects without serialization
class ComplexObject {
  final Function callback;
  final Stream stream;
  // No toJson method
}

// ✅ Good - Proper cleanup
@SSE('events')
Stream<String> sendEvents(CleanUp cleanUp) async* {
  final subscription = eventService.stream.listen((event) {
    // Handle events
  });

  cleanUp.add(() {
    subscription.cancel();
    resourceService.dispose();
  });

  yield* eventService.stream;
}

// ✅ Good - Limited duration streams
@SSE('updates')
Stream<String> sendUpdates() async* {
  for (int i = 0; i < 100; i++) {
    yield 'Update $i';
    await Future.delayed(const Duration(seconds: 1));
  }
  // Stream ends, connection closes
}

// ❌ Avoid - Infinite streams without cleanup
@SSE('updates')
Stream<String> sendUpdates() async* {
  while (true) {
    yield 'Update';
    await Future.delayed(const Duration(seconds: 1));
    // No way to stop this stream
  }
}