[Question]: forward(...) in onGraphQLError(...) callback does not trigger it again for the same error?

[RCSandberg]

Background:

I've setup a link chain as follows:
final link = errorLink.concat(authLink).concat(httpLink);

I've also setup an ErrorLink with the callback onGraphQLError: (request, forward, response) async* { ... }
In that callback I'm detecting an error which is handled by getting a new access token using a refresh token. I do that there in a method.

Then I yield* forward(request);

This works like a charm in the happy path example.

My understanding is that this works fine because forward() sends it to authLink which appends the new access token via callback getToken() and all is well.

Question:
Perhaps it's trivial... but I need to ask :)

If I deliberatley do yield* forward(request); WITHOUT refreshing the new token, I thought I would end up in an infinite loop where the same error occurs and I end up in callback onGraphQLError() again.

But it seems like I don't... Is that correct behavior? I mean, is there a guard somehow for that?

Kind regards,
Robert

[knaeckeKami]

You would not get an infinite loop this way- if you yield* forward(request), in your error link, forward is the httpLink without error link in front of it.

Here is a snippet for another error link that would actually allow this recursive loop to happen:

I use this for example for automatic retries on timeout errors.

/// like [ErrorLink], but with a twist:
/// the given [ExceptionHandler] handles [LinkException]s, like [ErrorLink],
/// but will also recursively forward errors until the given [ExceptionHandler] either
/// returns null or throws an exception (compared to ErrorLink, which can only handle a single error).
class RecursiveErrorLink extends Link {
  final ExceptionHandler onException;

  const RecursiveErrorLink({required this.onException});

  @override
  Stream<Response> request(Request request, [NextLink? forward]) async* {
    assert(
      forward != null,
      'RecursiveErrorLink is not a terminating link, therefore it must be given a forward link',
    );
    // forward the request the forward and check for errors
    await for (final result in Result.captureStream(forward!(request))) {
      if (result.isError) {
        final error = result.asError!.error;

        if (error is LinkException) {
          // here is the recursion -> the [NextLink] of the Exceptionhandler is [this.request] so
          // errors will be handled by this link again (with a potentially updated request)
          final stream = onException(request, (r) => this.request(r, forward), error);

          if (stream != null) {
            yield* stream;
            return;
          }
        }
        yield* Stream.error(error);
      } else {
        assert(result.isValue);
        //TODO: implement recursion also for `onGraphqlError`
        final response = result.asValue!.value;
        yield response;
      }
    }
  }
}

(only implemented for onException here, implemention for onGraphqlError would be similar.