Module twitch_api2::client

This is supported on crate feature client only.

Different clients you can use with this crate to call endpoints.

This enables you to use your own http client/implementation. For example, say you have a http client that has a "client" named foo::Client.

That client has a function call which looks something like this

fn call(&self, req: http::Request<Vec<u8>>) -> futures::future::BoxFuture<'static, Result<http::Response<Vec<u8>>, ClientError>> {
    ...
}

To use that for requests we do the following.

use twitch_api2::client::{BoxedFuture, Req, Response};
impl<'a> twitch_api2::HttpClient<'a> for foo::Client {
    type Error = foo::ClientError;

    fn req(&'a self, request: Req) -> BoxedFuture<'static, Result<Response, Self::Error>> {
        let fut = self.call(request);
        Box::pin(async {fut.await})
    }
}

We can then use it like usual.

pub struct MyStruct {
   twitch: TwitchClient<'static, foo::Client>,
   token: twitch_oauth2::AppAccessToken,
}

If your client is from a remote crate, you can use the newtype pattern

Of course, sometimes the clients use different types for their responses and requests. but simply translate them into http types and it will work.

See the source of this module for the implementation of Client for surf and reqwest if you need inspiration.

Structs

DummyHttpClient

A client that will never work, used to trick documentation tests

Enums

SurfError

Possible errors from Client::req() when using the surf client

Traits

Client

A client that can do requests

Type Definitions

BoxedFuture	A boxed future, mimics futures::future::BoxFuture
Req	The request type we're expecting with body.
Response	The response type we're expecting with body