client.rs

use std::{cell::LazyCell, str::FromStr, sync::Arc};

use crate::{error::Error, shapes::GetAccessTokenResponse, UserDetailResponse};

use reqwest::Client as ReqwestClient;
use tokio::runtime::{Builder as RuntimeBuilder, Runtime};
use url::Url;

pub const BASE_URL: LazyCell<Url> = LazyCell::new(|| Url::from_str("https://github.com").unwrap());
pub const API_BASE_URL: LazyCell<Url> =
    LazyCell::new(|| Url::from_str("https://api.github.com").unwrap());

/// A client for interacting with Github programmatically.
#[derive(Clone)]
pub struct GithubClient {
    http_client: ReqwestClient,
    /// The github client id. This one gets exposed publicly.
    client_id: String,
    /// The secret key that is known only to us and Github. Keep this
    /// one private!
    client_secret: String,
    /// The base url that authorization urls are based on.
    base_url: Url,
    /// The base url that the client uses to communicate with Github.
    api_base_url: Url,
}

#[derive(Debug, Clone)]
pub struct GithubSyncClient {
    client: GithubClient,
    rt: Arc<Runtime>,
}
impl GithubClient {
    /// Create a new Github client configured to use the public Github
    /// API.
    pub fn new(client_id: &str, client_secret: &str) -> Result<Self, Error> {
        Self::new_with_urls(
            client_id,
            client_secret,
            BASE_URL.clone(),
            API_BASE_URL.clone(),
        )
    }

    /// Create a new Github client configured to use arbitrary API
    /// endpoints.
    ///
    /// See also [`crate::fakehub::Fakehub::add_client`].
    pub fn new_with_urls(
        client_id: &str,
        client_secret: &str,
        base_url: Url,
        api_base_url: Url,
    ) -> Result<Self, Error> {
        Ok(Self {
            http_client: reqwest::ClientBuilder::new()
                .user_agent("Rust/request/ghoauth")
                .build()?,
            client_id: client_id.to_owned(),
            client_secret: client_secret.to_owned(),
            base_url,
            api_base_url,
        })
    }

    /// The URL to send a user to in order to start the OAuth workflow.
    pub fn authorization_url(&self) -> String {
        format!(
            "{}/#/oauth/authorize?client_id={}",
            self.base_url, self.client_id
        )
    }

    /// Exchange a login code for an access token.
    pub async fn get_access_token(&self, code: &str) -> Result<GetAccessTokenResponse, Error> {
        let params = [
            ("client_id", self.client_id.as_str()),
            ("client_secret", self.client_secret.as_str()),
            ("code", code),
        ];

        Ok(self
            .http_client
            .post(self.base_url.join("login/oauth/access_token")?)
            .form(&params)
            .header("Accept", "application/json")
            .send()
            .await?
            .json()
            .await?)
    }

    /// Use an access token to query the user this token is associated with.
    pub async fn get_user_detail(&self, access_token: &str) -> Result<UserDetailResponse, Error> {
        Ok(self
            .http_client
            .get(self.api_base_url.join("user")?)
            .header("Authorization", format!("token {}", access_token))
            .header("Accept", "application/json")
            .send()
            .await?
            .json()
            .await?)
    }

    /// Get a user's public profile.
    pub async fn get_user_detail_public(
        &self,
        username: &str,
    ) -> Result<UserDetailResponse, Error> {
        Ok(self
            .http_client
            .get(self.api_base_url.join(&format!("user/{}", username))?)
            .header("Accept", "application/json")
            .send()
            .await?
            .json()
            .await?)
    }
}

impl std::fmt::Debug for GithubClient {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        write!(
            f,
            "GithubClient {{ http_client: {:?}, client_id: {}, \
            client_secret: REDACTED }}",
            self.http_client, self.client_id,
        )
    }
}

impl GithubSyncClient {
    /// Create a new Github client configured to use the public Github
    /// API.
    pub fn new(client_id: &str, client_secret: &str) -> Result<Self, Error> {
        Ok(Self {
            client: GithubClient::new(client_id, client_secret)?,
            rt: create_current_thread_rt(),
        })
    }

    /// Create a new Github client configured to use arbitrary API
    /// endpoints.
    ///
    /// See also [`crate::fakehub::Fakehub::add_client`].
    pub fn new_with_urls(
        client_id: &str,
        client_secret: &str,
        base_url: Url,
        api_base_url: Url,
    ) -> Result<Self, Error> {
        Ok(Self {
            client: GithubClient::new_with_urls(client_id, client_secret, base_url, api_base_url)?,
            rt: create_current_thread_rt(),
        })
    }

    /// Create a new synchronous client by wrapping an existing
    /// asynchronous client.
    pub fn new_from_async_client(client: GithubClient) -> Self {
        Self {
            client,
            rt: create_current_thread_rt(),
        }
    }

    /// The URL to send a user to in order to start the OAuth workflow.
    pub fn authorization_url(&self) -> String {
        self.client.authorization_url()
    }

    /// Exchange a login code for an access token.
    pub fn get_access_token(&self, code: &str) -> Result<GetAccessTokenResponse, Error> {
        self.rt.block_on(self.client.get_access_token(code))
    }

    /// Use an access token to query the user this token is associated with.
    pub fn get_user_detail(&self, access_token: &str) -> Result<UserDetailResponse, Error> {
        self.rt.block_on(self.client.get_user_detail(access_token))
    }

    /// Get a user's public profile.
    pub fn get_user_detail_public(&self, username: &str) -> Result<UserDetailResponse, Error> {
        self.rt
            .block_on(self.client.get_user_detail_public(username))
    }
}

fn create_current_thread_rt() -> Arc<Runtime> {
    Arc::new(
        RuntimeBuilder::new_current_thread()
            .enable_io()
            .enable_time()
            .build()
            .expect("Cannot construct current-thread runtime"),
    )
}