view release on metacpan or  search on metacpan

README  view on Meta::CPAN

    
      my $tx1 = $client->resource('delete')->delete(
        json => {active => 1}
      );
    
      # is equivalent to
    
      my $tx2 = $client->resource('delete')->dispatch(
        method => 'delete',
        json => {active => 1}
      );
    
      [$tx1, $tx2]

    This example illustrates how you might delete a new API resource.

 fetching

      # given: synopsis
    
      my $tx1 = $client->resource('get')->fetch(
        query => {active => 1}
      );
    
      # is equivalent to
    
      my $tx2 = $client->resource('get')->dispatch(
        method => 'get',
        query => {active => 1}
      );
    
      [$tx1, $tx2]

    This example illustrates how you might fetch an API resource.

 subclassing

      package Hookbin;
    
      use Data::Object::Class;
    
      extends 'API::Client';
    
      sub auth {
        ['admin', 'secret']
      }
    
      sub headers {
        [['Accept', '*/*']]
      }
    
      sub base {
        ['https://httpbin.org/get']
      }
    
      package main;
    
      my $hookbin = Hookbin->new;

    This package was designed to be subclassed and provides hooks into the
    client building and request dispatching processes. Specifically, there
    are three useful hooks (i.e. methods, which if present are used to
    build up the client object and requests), which are, the auth hook,
    which should return a Tuple[Str, Str] which is used to configure the
    basic auth header, the base hook which should return a Tuple[Str] which
    is used to configure the base URL, and the headers hook, which should
    return a ArrayRef[Tuple[Str, Str]] which are used to configure the HTTP
    request headers.

 transacting

      # given: synopsis
    
      my $tx1 = $client->resource('patch')->patch(
        json => {active => 1}
      );
    
      # is equivalent to
    
      my $tx2 = $client->resource('patch')->dispatch(
        method => 'patch',
        json => {active => 1}
      );
    
      [$tx1, $tx2]

    An HTTP request is only issued when the "dispatch" method is called,
    directly or indirectly. Those calls return a Mojo::Transaction object
    which provides access to the request and response objects.

 updating

      # given: synopsis
    
      my $tx1 = $client->resource('put')->update(
        json => {active => 1}
      );
    
      # is equivalent to
    
      my $tx2 = $client->resource('put')->dispatch(
        method => 'put',
        json => {active => 1}
      );
    
      [$tx1, $tx2]

    This example illustrates how you might update a new API resource.

ATTRIBUTES

    This package has the following attributes:

 debug

      debug(Bool)

    This attribute is read-only, accepts (Bool) values, and is optional.

 fatal

README  view on Meta::CPAN

      
        $client->resource('patch')->dispatch(
          method => 'patch', json => {active => 1}
        );

    dispatch example #8

        # given: synopsis
      
        $client->resource('delete')->dispatch(
          method => 'delete', json => {active => 1}
        );

 fetch

      fetch(Any %args) : InstanceOf["Mojo::Transaction"]

    The fetch method issues a GET request to the API resource represented
    by the object.

    fetch example #1

        # given: synopsis
      
        $client->resource('get')->fetch;

 patch

      patch(Any %args) : InstanceOf["Mojo::Transaction"]

    The patch method issues a PATCH request to the API resource represented
    by the object.

    patch example #1

        # given: synopsis
      
        $client->resource('patch')->patch(
          json => {active => 1}
        );

 prepare

      prepare(Object $ua, Object $tx, Any %args) : Object

    The prepare method acts as a before hook triggered before each request
    where you can modify the transactor objects.

    prepare example #1

        # given: synopsis
      
        require Mojo::UserAgent;
        require Mojo::Transaction::HTTP;
      
        $client->prepare(
          Mojo::UserAgent->new,
          Mojo::Transaction::HTTP->new
        );

 process

      process(Object $ua, Object $tx, Any %args) : Object

    The process method acts as an after hook triggered after each response
    where you can modify the transactor objects.

    process example #1

        # given: synopsis
      
        require Mojo::UserAgent;
        require Mojo::Transaction::HTTP;
      
        $client->process(
          Mojo::UserAgent->new,
          Mojo::Transaction::HTTP->new
        );

 resource

      resource(Str @segments) : Object

    The resource method returns a new instance of the object for the API
    resource endpoint specified.

    resource example #1

        # given: synopsis
      
        $client->resource('status', 200);

 serialize

      serialize() : HashRef

    The serialize method serializes and returns the object as a hashref.

    serialize example #1

        # given: synopsis
      
        $client->serialize;

 update

      update(Any %args) : InstanceOf["Mojo::Transaction"]

    The update method issues a PUT request to the API resource represented
    by the object.

    update example #1

        # given: synopsis
      
        $client->resource('put')->update(
          json => {active => 1}
        );

AUTHOR

    Al Newkirk, awncorp@cpan.org

LICENSE

    Copyright (C) 2011-2019, Al Newkirk, et al.

    This is free software; you can redistribute it and/or modify it under
    the terms of the The Apache License, Version 2.0, as elucidated in the
    "license file"
    <https://github.com/iamalnewkirk/api-client/blob/master/LICENSE>.

PROJECT

    Wiki <https://github.com/iamalnewkirk/api-client/wiki>