NAME

MooX::Role::HTTP::Tiny - HTTP::Tiny as a role for clients that use HTTP

SYNOPSIS

package My::Client;
use Moo;
with qw< MooX::Role::HTTP::Tiny >;
use JSON qw< encode_json >;

# implent a call to the API of a webservice
sub call {
    my $self = shift;
    my ($method, $path, $args) = @_;

    my $uri = $self->base_uri->clone;
    $uri->path($uri->path =~ m{ / $}x ? $uri->path . $path : $path)
        if $path;

    my @params = $args ? ({ content => encode_json($args) }) : ();
    if (uc($method) eq 'GET') {
        my $query = $self->www_form_urlencode($args);
        $uri->query($query);
        shift(@params);
    }

    printf STDERR ">>>>> %s => %s (%s) <<<<<\n", uc($method), $uri, "@params";
    my $response = $self->request(uc($method), $uri, @params);
    if (not $response->{success}) {
        die sprintf "ERROR: %s: %s\n", $response->{reason}, $response->{content};
    }
    return $response;
}
1;

package My::API;
use Moo;
use Types::Standard qw< InstanceOf >;
has client => (
    is       => 'ro',
    isa      => InstanceOf(['My::Client']),
    handles  => [qw< call >],
    required => 1,
);
sub fetch_stuff {
    my $self = shift;
    return $self->call(@_);
}
1;

package main;
use My::Client;
use My::API;

my $client = My::Client->new(
    base_uri => ' https://fastapi.metacpan.org/v1/release/_search'
);
my $api = My::API->new(client => $client);
my $response = $api->fetch_stuff(get => '', {q => 'MooX-Role-HTTP-Tiny'});
print $response->{content};

ATTRIBUTES

base_uri [REQUIRED] The base-uri to the webservice

The provided uri will be coerced into a URI instance.

ua A (lazy build) instance of HTTP::Tiny

When none is provided, Moo will instantiate a HTTP::Tiny with the extra options provided in the ua_options attribute whenever it is first needed.

The request and www_form_urlencode methods will be handled for the role.

ua_options passed through to the constructor of HTTP::Tiny on lazy-build

These options can only be passed to constructor of HTTP::Tiny, so won't have impact when an already instantiated ua attribute is provided.

REQUIRES

The class that consumes this role needs to implement the method call() as a wrapper around HTTP::Tiny::request to suit the remote API one is writing the client for.

DESCRIPTION

This role provides a basic HTTP useragent (based on HTTP::Tiny) for classes that want to implement a client to any webservice that uses the HTTP(S) transport protocol.

Some best known protocols are XMLRPC, JSONRPC and REST, and can be implemented through the required call() method.

COPYRIGHT

© MMXXI - Abe Timmerman <abeltje@cpan.org>

LICENSE

This library is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.