get method

Future<ClientResult> get({
  1. required String url,
  2. Map<String, String>? headers,
  3. Map<String, String>? queryParameters,
  4. Duration? timeout,
  5. ClientType? clientType,
  6. String? cancelKey,
  7. OnSuccess? onSuccess,
  8. OnError? onError,
  9. OnHttpError? onHttpError,
  10. Map<int, OnStatus>? onStatus,
  11. Set<int>? successCodes,
  12. Set<int>? errorCodes,
})

Performs a GET request and returns the result as a tuple.

Optionally accepts callbacks for convenient response handling. When callbacks are provided, they are invoked based on the response status code, but the result tuple is still returned.

Example with tuple only:

final (response, error) = await client.get(url: '/users');
if (error != null) {
  print('Error: ${error.message}');
} else {
  print('Success: ${response!.body}');
}

Example with callbacks:

await client.get(
  url: 'https://api.example.com/users',
  onSuccess: (response) => print('Got ${response.body}'),
  onError: (error) => print('Error: ${error.message}'),
  onHttpError: (code, response) => print('HTTP $code'),
  successCodes: {200, 201},
  onStatus: {
    401: (code, response) => refreshToken(),
    429: (code, response) => handleRateLimit(),
  },

Implementation

Future<ClientResult> get({
  required String url,
  Map<String, String>? headers,
  Map<String, String>? queryParameters,
  Duration? timeout,
  ClientType? clientType,
  String? cancelKey,
  // Optional callbacks
  OnSuccess? onSuccess,
  OnError? onError,
  OnHttpError? onHttpError,
  Map<int, OnStatus>? onStatus,
  Set<int>? successCodes,
  Set<int>? errorCodes,
}) async {
  final fullUrl = _buildUrl(url);
  final request = ClientRequest(
    url: fullUrl,
    method: 'GET',
    headers: {...config.defaultHeaders, ...?headers},
    queryParameters: queryParameters,
  );

  final processedRequest = await _runRequestInterceptors(request);
  if (processedRequest == null) {
    final result = (
      null,
      ClientException(
          message: 'Request cancelled by interceptor', url: fullUrl)
    );
    _handleCallbacks(
      response: result.$1,
      error: result.$2,
      onSuccess: onSuccess,
      onError: onError,
      onHttpError: onHttpError,
      onStatus: onStatus,
      successCodes: successCodes,
      errorCodes: errorCodes,
    );
    return result;
  }

  // Check for cached response
  final cachedResponse =
      processedRequest.extra['cachedResponse'] as ClientResponse?;
  if (cachedResponse != null) {
    final response =
        await _runResponseInterceptors(processedRequest, cachedResponse);
    final result = (response, null);
    _handleCallbacks(
      response: result.$1,
      error: result.$2,
      onSuccess: onSuccess,
      onError: onError,
      onHttpError: onHttpError,
      onStatus: onStatus,
      successCodes: successCodes,
      errorCodes: errorCodes,
    );
    return result;
  }

  final result = await _executeWithRetry(
    request: processedRequest,
    execute: () =>
        _performGet(processedRequest, timeout, clientType, cancelKey),
  );

  _handleCallbacks(
    response: result.$1,
    error: result.$2,
    onSuccess: onSuccess,
    onError: onError,
    onHttpError: onHttpError,
    onStatus: onStatus,
    successCodes: successCodes,
    errorCodes: errorCodes,
  );

  return result;
}