oauth2-twitch 0.2.0

OAuth 2.0 Twitch
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use oauth2_client::{
    extensions::{EndpointParseResponseError, EndpointRenderRequestError, UserInfo},
    re_exports::{serde_json, Body, Endpoint, Request, Response},
};

use super::internal_users_endpoint::{Users, UsersEndpoint, UsersEndpointError};

//
#[derive(Debug, Clone)]
pub struct TwitchUserInfoEndpoint {
    inner: UsersEndpoint,
}
impl TwitchUserInfoEndpoint {
    pub fn new(access_token: impl AsRef<str>, client_id: impl AsRef<str>) -> Self {
        Self {
            inner: UsersEndpoint::new(access_token, client_id),
        }
    }
}

impl Endpoint for TwitchUserInfoEndpoint {
    type RenderRequestError = EndpointRenderRequestError;

    type ParseResponseOutput = UserInfo;
    type ParseResponseError = EndpointParseResponseError;

    fn render_request(&self) -> Result<Request<Body>, Self::RenderRequestError> {
        self.inner.render_request().map_err(Into::into)
    }

    fn parse_response(
        &self,
        response: Response<Body>,
    ) -> Result<Self::ParseResponseOutput, Self::ParseResponseError> {
        UserInfo::try_from(self.inner.parse_response(response)?)
            .map_err(EndpointParseResponseError::ToOutputFailed)
    }
}

//
impl From<UsersEndpointError> for EndpointRenderRequestError {
    fn from(err: UsersEndpointError) -> Self {
        match err {
            UsersEndpointError::MakeRequestFailed(err) => Self::MakeRequestFailed(err),
            UsersEndpointError::DeResponseBodyFailed(err) => Self::Other(Box::new(err)),
        }
    }
}
impl From<UsersEndpointError> for EndpointParseResponseError {
    fn from(err: UsersEndpointError) -> Self {
        match err {
            UsersEndpointError::MakeRequestFailed(err) => Self::Other(Box::new(err)),
            UsersEndpointError::DeResponseBodyFailed(err) => Self::DeResponseBodyFailed(err),
        }
    }
}

//
impl TryFrom<Users> for UserInfo {
    type Error = Box<dyn std::error::Error + Send + Sync>;

    fn try_from(users: Users) -> Result<Self, Self::Error> {
        let user = users.data.first().cloned().ok_or("not found user")?;

        Ok(Self {
            uid: user.id.to_owned(),
            name: Some(user.login.to_owned()),
            email: user.email.to_owned(),
            raw: serde_json::to_value(user)
                .map(|x| x.as_object().cloned())?
                .ok_or_else(|| "unreachable".to_owned())?,
        })
    }
}