fetchLive method

Stream<SanityQueryResponse> fetchLive(
  1. String query, {
  2. Map<String, String>? params,
  3. bool includeDrafts = false,
})

Fetches live query results. Requests are serialized and bursts coalesced. Errors are delivered through the returned stream; cancelling disconnects SSE.

Implementation

Stream<SanityQueryResponse> fetchLive(
  String query, {
  Map<String, String>? params,
  bool includeDrafts = false,
}) {
  if (includeDrafts &&
      (config.perspective != Perspective.drafts || config.useCdn)) {
    throw ArgumentError(
      'Draft live queries require the drafts perspective without CDN',
    );
  }
  final liveConfig = includeDrafts ? LiveConfig.withDrafts() : LiveConfig();
  final uri = SanityRequest(
    urlBuilder: urlBuilder,
    query: '',
    live: liveConfig,
  ).getUri;
  final headers = Map<String, String>.from(_requestHeaders)
    ..['Accept'] = 'text/event-stream';
  late final StreamController<SanityQueryResponse> controller;
  late final LiveEventSource source;
  StreamSubscription<LiveEvent>? subscription;
  var cancelled = false;
  var generation = 0;
  var fetching = false;
  var pending = false;
  String? lastEventId;
  List<String>? syncTags;

  void report(Object error, [StackTrace? stack]) {
    if (!cancelled && !controller.isClosed) controller.addError(error, stack);
  }

  Future<void> fetchQuery() async {
    pending = true;
    if (fetching) return;
    fetching = true;
    try {
      while (pending && !cancelled) {
        pending = false;
        final requestGeneration = generation;
        try {
          final response = await fetch(
            query,
            params: {...?params, 'lastLiveEventId': lastEventId ?? ''},
          );
          if (!cancelled && requestGeneration == generation && !pending) {
            syncTags = response.syncTags;
            controller.add(response);
          }
        } catch (error, stack) {
          if (requestGeneration == generation && !pending) {
            report(error, stack);
          }
        }
      }
    } finally {
      fetching = false;
    }
  }

  void listener(LiveEvent event) {
    if (cancelled) return;
    try {
      switch (_LiveEventType.fromEvent(event)) {
        case _LiveEventType.welcome || _LiveEventType.restart:
          lastEventId = event.id;
          unawaited(fetchQuery());
        case _LiveEventType.message:
          lastEventId = event.id;
          final data = jsonDecode(event.data) as Map<String, dynamic>;
          final tags = (data['tags'] as List?)?.cast<String>();
          if (syncTags == null || (tags?.any(syncTags!.contains) ?? false)) {
            unawaited(fetchQuery());
          }
        case _LiveEventType.error:
          report(LiveConnectException('Live data error for query: $query'));
        default:
          break;
      }
    } catch (error, stack) {
      report(error, stack);
    }
  }

  source = LiveEventSource(
    httpClient: httpClient,
    uri: uri,
    headers: headers,
    onConnected: (events) {
      if (cancelled) {
        unawaited(source.close());
        return;
      }
      generation++;
      syncTags = null;
      final connectionGeneration = generation;
      unawaited(subscription?.cancel());
      subscription = events.listen((event) {
        if (connectionGeneration == generation) listener(event);
      });
      if (fetching) pending = true;
    },
    onError: (error) =>
        report(LiveConnectException('Live connection failed: $error')),
  );
  controller = StreamController<SanityQueryResponse>(
    onListen: source.connect,
    onCancel: () async {
      cancelled = true;
      generation++;
      pending = false;
      // Closing first stops the connection and any reconnect at once.
      final closed = source.close();
      try {
        await subscription?.cancel();
      } finally {
        await closed;
      }
    },
  );
  return controller.stream;
}