QueryBloc<TData> constructor

QueryBloc<TData>({ required GraphQLClient client, required WatchQueryOptions<Object?> options, })

Implementation

QueryBloc({required this.client, required WatchQueryOptions options})
    : super(QueryState<TData>.initial()) {
  on<QueryEventRun<TData>>(
    _run,
    transformer: runTransformer?.call(),
  );
  on<QueryEventError<TData>>(
    _error,
    transformer: errorTransformer?.call(),
  );
  on<QueryEventLoading<TData>>(
    _loading,
    transformer: loadingTransformer?.call(),
  );
  on<QueryEventLoaded<TData>>(
    _loaded,
    transformer: loadedTransformer?.call(),
  );
  on<QueryEventRefetch<TData>>(
    _refetch,
    transformer: refetchTransformer?.call(),
  );
  on<QueryEventFetchMore<TData>>(
    _fetchMore,
    transformer: fetchMoreTransformer?.call(),
  );

  result = client.watchQuery<void>(options);

  _subscription = result.stream.listen((QueryResult result) {
    if (state is QueryStateRefetch &&
        result.source == QueryResultSource.cache &&
        options.fetchPolicy == FetchPolicy.cacheAndNetwork) {
      return;
    }

    final exception = result.exception;

    if (exception != null) {
      TData? data;

      if (result.data != null) {
        data = parseData(result.data);
      }

      if (!isClosed) {
        add(QueryEvent<TData>.error(
          error: exception,
          result: result,
          data: data,
        ));
      }
    }

    if (result.isLoading && result.data == null) {
      if (!isClosed) {
        add(QueryEvent.loading(result: result));
      }
    }

    if (!result.isLoading && result.data != null) {
      if (!isClosed) {
        add(
          QueryEvent<TData>.loaded(
            data: parseData(result.data),
            result: result,
          ),
        );
      }
    }
  });
}