Need more headers in AuthLink

[endigo]

Our API service uses access-token and refresh token.

Here just one header: 'Authorization'
/~https://github.com/zino-app/graphql-flutter/blob/next/lib/src/link/auth/link_auth.dart#L21

We need 3 custom named headers.
for example:

HttpLink(uri: global.graphqlEndpoint, headers: {
  'x-token': state.user.accessToken,
  'x-refresh-token': state.user.refreshToken,
  'accept-language': locale.toString()
}),

Thanks.

[HofmannZ]

You can write your own Link:

typedef GetHeaders = Future<Map<String, String>> Function();

class CustomAuthLink extends Link {
  CustomAuthLink({
    this.getHeaders,
  }) : super(
          request: (Operation operation, [NextLink forward]) {
            StreamController<FetchResult> controller;

            Future<void> onListen() async {
              try {
                final Map<String, String> headers = await getHeaders();

                operation.setContext(<String, Map<String, String>>{
                  'headers': headers
                });
              } catch (error) {
                controller.addError(error);
              }

              await controller.addStream(forward(operation));
              await controller.close();
            }

            controller = StreamController<FetchResult>(onListen: onListen);

            return controller.stream;
          },
        );

  GetHeaders getHeaders;
}

And then you can implement it just as you would with the AuthLink.

Hope that helps!

[HofmannZ]

Closing, seems revolved.

[5hanth]

@HofmannZ need to reopen this as the above CustomAuthLink's parameter signatures fails for 4.0.0

[HofmannZ]

@5hanth we moved to a new link system, see /~https://github.com/zino-app/graphql-flutter/blob/beta/changelog-v3-v4.md#we-now-use-the-gql_link-system

[bgparkerdev]

If people are having a hard time finding an example. /~https://github.com/gql-dart/gql/blob/master/links/gql_link/example/gql_link_example.dart

[MSRPRO]

You can create your own link (updated answer 2021) :

import 'dart:async';

import 'package:graphql/client.dart';

typedef _RequestTransformer = FutureOr<Request> Function(Request request);

class CustomAuthLink extends _AsyncReqTransformLink {
  CustomAuthLink({
    required this.getHeaders,
  }) : super(requestTransformer: transform(getHeaders));

  final FutureOr<Map<String, String>>? Function() getHeaders;

  static _RequestTransformer transform(
    FutureOr<Map<String, String>>? Function() getHeaders,
  ) =>
      (Request request) async {
        final Map<String, String>? headers = await getHeaders();
        return request.updateContextEntry<HttpLinkHeaders>(
          (_headers) => HttpLinkHeaders(
            headers: headers!,
          ),
        );
      };
}

class _AsyncReqTransformLink extends Link {
  final _RequestTransformer requestTransformer;

  _AsyncReqTransformLink({
    required this.requestTransformer,
  });

  @override
  Stream<Response> request(
    Request request, [
    NextLink? forward,
  ]) async* {
    final req = await requestTransformer(request);

    yield* forward!(req);
  }
}

[SamerOrfali22]

I think the previous solutions are expired and the new link system and the example is not simple to understand and use, so
here is my the straight forward solution when you have dynamic headers for each request
in my case I need to send the current language for example with each request

so first I have singleton service has one instance of the client with the default headers

 class GraphqlService {
  final GraphQLClient _client;

  GraphqlService._(this._client);

  static GraphqlService? _instance;

  static Future<GraphqlService> instance() async {
    if (_instance != null) {
      return _instance!;
    }
    final HttpLink httpLink = HttpLink(
      AppConfig.graphqlUrl,
      defaultHeaders: CommonHttp.defaultHeaders,
      useGETForQueries: false,
    );

    final graphQlClient = GraphQLClient(
      cache: GraphQLCache(),
      link: httpLink,
    );

    _instance = GraphqlService._(graphQlClient);
    return _instance!;
  }

  Future<QueryResult> query(QueryOptions options) async {
    return await _client.query(options);
  }

  Future<QueryResult> mutate(MutationOptions options) async {
    return await _client.mutate(options);
  }
}

and using the query like this

  final client = await GraphqlService.instance();
      final dynamicHeaders = await CommonHttp.getDynamicHeaders();

      final result = await client.query(
        QueryOptions(
          document: gql(query),
          variables: variables,
          context: Context.fromList([
            HttpLinkHeaders(headers: dynamicHeaders),
          ]),
        ),
      );

so the dynamic headers will be added to the default headers in each request

also you can add RequestExtensionsThunk,HttpLinkResponseContext,ResponseExtensions to this list.