paylike_dart_client 1.0.10

Higher level API client for Paylike.io to provide a handy interface for constructing requests towards paylike.io

Paylike Dart API client

This is an ALPHA release

Although the functionality included is production quality, the supported scope of the API is merely a stub.

High-level client for the API documented at: https://github.com/paylike/api-reference. It is using paylike_dart_request under the hood.

Examples

dart pub add paylike_dart_client

import 'package:paylike_dart_client/paylike_dart_client.dart';

void main() {
  var client = PaylikeClient('MY_CLIENT_ID');

  PaylikeRequestBuilder<TokenizedResponse> request = client.tokenize(TokenizeTypes.PCN, '1000000000000000');
  request.execute().then((response) {
    print('Received token: ' + response.token);
  }).catchError((e) => print(e));
}

Methods

// client.tokenize(TokenizeTypes.PCN, '...');
// client.tokenize(TokenizeTypes.PCSC, '...');
PaylikeRequestBuilder<TokenizedResponse> tokenize(TokenizeTypes type, String value);

// client.paymentCreate(payment);
PaylikeRequestBuilder<PaymentResponse> paymenCreate({
  required Map<String, dynamic> payment,
  List<String> hints = const [],
});

More information on payment data structure.

Error handling

The methods may throw any error forwarded from the used PaylikeRequester implementation as well as one of the below error classes.

• RateLimitException

  May have a retryAfter (Duration) property if sent by the server specifying the minimum delay.

• TimeoutException

  Comes from dart:async library https://api.dart.dev/be/169657/dart-async/TimeoutException-class.html

• ServerErrorException

  Has status and headers properties copied from the io.HttpClientResponse

• PaylikeException

  These errors correspond to status codes from the API reference. They have at least a code and message property, but may also have other useful properties relevant to the specific error code, such as a minimum and maximum for amounts.

Logging

Pass a log function of the format void Function(dynamic d) to catch internal (structured) logging.

  var client = PaylikeClient('MY_CLIENT_ID').setLog((dynamic d) => print(d))

Timeouts and retries

There is a default timeout for all HTTPS requests of 10 seconds and a retry strategy of 10 retries with increasing delay.

      switch (attempts) {
        case 0:
        case 1:
          usedDuration = Duration(milliseconds: 0);
          break;
        case 2:
          usedDuration = Duration(milliseconds: 100);
          break;
        case 3:
          usedDuration = Duration(seconds: 2);
          break;
        default:
          usedDuration = Duration(seconds: 10);
      }

Using the default retry handler is recommended which you can do by specifying on the PaylikeRequestBuilder you receive:

      var request = client
          .tokenize(TokenizeTypes.PCN, '4100000000000000')
          .withDefaultRetry();
      var response = await request.execute();

You can also create your own handler by implementing the RetryHandler abstract class:

class CustomRetryHandler<T> implements RetryHandler<T> {
  int attempts = 0;
  @override
  Future<T> retry(Future<T> Function() executor) async {
    try {
      var res = await executor();
      return res;
    } on RateLimitException catch (e) {
      attempts++;
      if (attempts > 10) {
        rethrow;
      }
      await Future.delayed(Duration(seconds: 5));
    } catch (e) {
      rethrow;
    }
    return retry(executor);
  }
}

// Then you can apply your own retry handler to the request builder:
var request = client
      .tokenize(TokenizeTypes.PCN, '4100000000000000')
      .withRetry(CustomRetryHandler<TokenizedResponse>());
var response = await request.execute();