Struct twitch_api::TwitchClient

#[non_exhaustive]
pub struct TwitchClient<'a, C>where
    C: HttpClient<'a>,{
    pub helix: HelixClient<'a, C>,
    pub tmi: TmiClient<'a, C>,
}

Available on crate feature client and (crate features helix or tmi) only.

Client for Twitch APIs.

Most http clients will be able to use the 'static lifetime

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

See client for implemented clients, you can also define your own if needed.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

helix: HelixClient<'a, C>

Available on crate feature helix only.

Helix endpoint. See helix

tmi: TmiClient<'a, C>

Available on crate feature tmi only.

TMI endpoint. See tmi

Implementations

impl<C: HttpClient<'static>> TwitchClient<'static, C>

pub fn new() -> TwitchClient<'static, C>where
    C: Clone + ClientDefault<'static>,

Create a new TwitchClient

Examples found in repository

src/lib.rs (line 207)

    fn default() -> Self { Self::new() }

examples/get_streams_and_chatters.rs (line 9)

↕

async fn main() {
    let _ = dotenvy::dotenv();
    let mut args = std::env::args().skip(1);
    let client: TwitchClient<reqwest::Client> = TwitchClient::new();
    let token = UserToken::from_existing(
        &client,
        std::env::var("TWITCH_TOKEN")
            .ok()
            .or_else(|| args.next())
            .map(AccessToken::new)
            .expect("Please set env: TWITCH_TOKEN or pass token as first argument"),
        None,
        None,
    )
    .await
    .unwrap();

    let streams: Vec<String> = args.collect();
    let req = GetStreamsRequest::default();

    let response = client.helix.req_get(req, &token).await.unwrap();

    // Note: This will fetch chatters in the current most viewed stream, might spam your console a bit.
    println!("GetStreams:\n\t{:?}", response.data);
    if let Some(stream) = streams.get(0) {
        println!(
            "{:?}",
            client.tmi.get_chatters(stream.as_str().into()).await
        );
    } else if let Some(stream) = response.data.get(0).map(|stream| &stream.user_login) {
        println!("{:?}", client.tmi.get_chatters(stream).await);
    }
}

impl<'a, C: HttpClient<'a>> TwitchClient<'a, C>

pub fn with_client(client: C) -> TwitchClient<'a, C>where
    C: Clone,

Create a new TwitchClient with an existing HttpClient

Examples found in repository

src/lib.rs (line 201)

    pub fn new() -> TwitchClient<'static, C>
    where C: Clone + client::ClientDefault<'static> {
        let client = C::default_client();
        Self::with_client(client)
    }

pub fn get_client(&self) -> &C

Retrieve a reference of the HttpClient inside this TwitchClient

Examples found in repository

src/client.rs (line 336)

↕

    fn req(
        &'a self,
        request: http::Request<Vec<u8>>,
    ) -> BoxedFuture<
        'a,
        Result<http::Response<Vec<u8>>, <Self as twitch_oauth2::client::Client>::Error>,
    > {
        let client = self.get_client();
        {
            let request = request.map(Bytes::from);
            let resp = client.req(request);
            Box::pin(async {
                let resp = resp.await?;
                let (parts, mut body) = resp.into_parts();
                Ok(http::Response::from_parts(
                    parts,
                    hyper::body::to_bytes(&mut body)
                        .await
                        .map_err(CompatError::BodyError)?
                        .to_vec(),
                ))
            })
        }
    }

Trait Implementations

impl<'a, C: Client<'a> + Sync> Client<'a> for TwitchClient<'a, C>

Available on crate features tmi or helix only.

type Error = CompatError<<C as Client<'a>>::Error>

Error returned by the client

fn req(
    &'a self,
    request: Request<Vec<u8>>
) -> BoxedFuture<'a, Result<Response<Vec<u8>>, <Self as Client<'_>>::Error>>

Send a request

impl<'a, C: Clone> Clone for TwitchClient<'a, C>where
    C: HttpClient<'a>,

fn clone(&self) -> TwitchClient<'a, C>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<C: HttpClient<'static> + ClientDefault<'static>> Default for TwitchClient<'static, C>

fn default() -> Self

Returns the “default value” for a type.