use yapma_common::http;

        let client = reqwest::Client::builder().user_agent("nestje").build()?;

        let client = http::client();

            Platform::Github => Github::new(username.as_ref(), client).resolve().await?,
            Platform::Gitlab => Gitlab::new(username.as_ref(), client).resolve().await?,

            Platform::Github => Github::new(username.as_ref()).resolve(client).await?,
            Platform::Gitlab => Gitlab::new(username.as_ref()).resolve(client).await?,

use anyhow::bail;

use reqwest::Response;
use tracing::debug;

use yapma_common::http;

    async fn resolve(&self) -> Result<Keys, Self::Error> {
        tokio::try_join!(self.resolve_ssh(), self.resolve_gpg()).map(|(ssh, gpg)| Keys { ssh, gpg })

    async fn resolve<C: http::Client + Send>(&self, client: C) -> Result<Keys, Self::Error> {
        tokio::try_join!(self.resolve_ssh(&client), self.resolve_gpg(&client))
            .map(|(ssh, gpg)| Keys { ssh, gpg })

    async fn resolve_ssh(&self) -> Result<HashSet<ssh::PublicKey>, Self::Error>;
    async fn resolve_gpg(

    async fn resolve_ssh<C: http::Client>(
        &self,
        client: &C,
    ) -> Result<HashSet<ssh::PublicKey>, Self::Error>;
    async fn resolve_gpg<C: http::Client>(

        client: &C,

}
#[async_trait]
pub trait ResponseExt: Sized {
    async fn succeed(self) -> anyhow::Result<Self>;
}
#[async_trait]
impl ResponseExt for Response {
    async fn succeed(self) -> anyhow::Result<Self> {
        debug!("{}", self.status());
        if !self.status().is_success() {
            debug!("{:#?}", self.headers());
            let body = self.text().await?;
            bail!(body)
        }
        Ok(self)
    }

use yapma_common::http::{
    self,
    Response as _,
};

    resolver::{
        Resolver,
        ResponseExt as _,
    },

    resolver::Resolver,

    client: reqwest::Client,

    pub const fn new(username: &'a str, client: reqwest::Client) -> Self {
        Self { username, client }

    pub const fn new(username: &'a str) -> Self {
        Self { username }

    async fn resolve_ssh(&self) -> Result<HashSet<ssh::PublicKey>, Self::Error> {

    async fn resolve_ssh<C: http::Client>(
        &self,
        client: &C,
    ) -> Result<HashSet<ssh::PublicKey>, Self::Error> {

        let keys = self
            .client

        let keys = client

            .send()
            .await?
            .succeed()

    async fn resolve_gpg(

    async fn resolve_gpg<C: http::Client>(

        client: &C,

            let mut user = self
                .client
                .get(url.as_str())
                .send()
                .await?
                .succeed()
                .await?
                .json::<Vec<User>>()
                .await?;

            let mut user = client.get(url.as_str()).await?.json::<Vec<User>>().await?;

        let keys = self
            .client

        let keys = client

            .send()

            .succeed()
            .await?

use yapma_common::http::{
    self,
    Response as _,
};

    resolver::{
        Resolver,
        ResponseExt as _,
    },

    resolver::Resolver,

    client: reqwest::Client,

    pub const fn new(username: &'a str, client: reqwest::Client) -> Self {
        Self { username, client }

    pub const fn new(username: &'a str) -> Self {
        Self { username }

    async fn resolve_ssh(&self) -> Result<HashSet<ssh::PublicKey>, Self::Error> {

    async fn resolve_ssh<C: http::Client>(
        &self,
        client: &C,
    ) -> Result<HashSet<ssh::PublicKey>, Self::Error> {

        let keys = self
            .client

        let keys = client

            .send()
            .await?
            .succeed()

    async fn resolve_gpg(

    async fn resolve_gpg<C: http::Client>(

        client: &C,

        let keys = self
            .client

        let keys = client

            .send()
            .await?
            .succeed()

use yapma_common::http::{
    self,
    Response as _,
};

#[derive(Debug, PartialEq, serde::Deserialize)]

#[derive(Clone, Debug, PartialEq, serde::Deserialize)]

    pub async fn resolve(&self) -> anyhow::Result<PartialDocument> {

    pub async fn resolve<C: http::Client>(&self, client: &C) -> anyhow::Result<PartialDocument> {

        Ok(reqwest::get(url).await?.json().await?)

        client.get(url).await?.json().await

use test_log::test;

    let doc = super::create(did.clone(), ed25519::KeyPair::generate().pk);
    let client = http::mock_client(|url| {
        assert_eq!(url, Url::parse("https://eagain.io/kim/did.json").unwrap());
        let body = serde_json::to_string(&doc)
            .map(reqwest::Body::from)
            .unwrap();
        ::http::Response::builder()
            .status(http::StatusCode::OK)
            .header("Content-Type", "application/json")
            .body(body)
            .unwrap()
    });

        .block_on(did.resolve())

        .block_on(did.resolve(&client))

yapma-common = { path = "../common" }

yapma-common = { path = "../common", features = ["testing"] }
http.workspace = true

// Copyright © 2023 Kim Altintop <kim@eagain.io>
// SPDX-License-Identifier: GPL-2.0-only
pub mod http;

// Copyright © 2023 Kim Altintop <kim@eagain.io>
// SPDX-License-Identifier: GPL-2.0-only
use anyhow::bail;
use async_trait::async_trait;
use serde::de::DeserializeOwned;
use tracing::debug;
use url::Url;
pub use http::{
    HeaderMap,
    StatusCode,
};
pub type Result<T> = anyhow::Result<T>;
pub trait IntoUrl: Send {
    fn into_url(self) -> Result<Url>;
}
impl IntoUrl for Url {
    fn into_url(self) -> Result<Url> {
        Ok(self)
    }
}
impl<'a> IntoUrl for &'a str {
    fn into_url(self) -> Result<Url> {
        Ok(Url::parse(self)?)
    }
}
impl IntoUrl for String {
    fn into_url(self) -> Result<Url> {
        Ok(Url::parse(self.as_str())?)
    }
}
#[async_trait]
pub trait Client: Send + Sync {
    type Response: Response;
    async fn get<U: IntoUrl>(&self, url: U) -> Result<Self::Response>;
}
#[async_trait]
pub trait Response: Send + Sync {
    async fn text(self) -> Result<String>;
    async fn json<T: DeserializeOwned>(self) -> Result<T>;
    fn status(&self) -> StatusCode;
    fn content_length(&self) -> Option<u64>;
    fn headers(&self) -> &HeaderMap;
}
#[async_trait]
impl Client for reqwest::Client {
    type Response = reqwest::Response;
    async fn get<U: IntoUrl>(&self, url: U) -> Result<Self::Response> {
        let resp = self.get(url.into_url()?).send().await?;
        let status = resp.status();
        debug!("{status}");
        if !status.is_success() {
            debug!("{:#?}", resp.headers());
            let body = resp.text().await?;
            bail!(body);
        }
        Ok(resp)
    }
}
#[async_trait]
impl Response for reqwest::Response {
    async fn text(self) -> Result<String> {
        Ok(self.text().await?)
    }
    async fn json<T: DeserializeOwned>(self) -> Result<T> {
        Ok(self.json().await?)
    }
    fn status(&self) -> StatusCode {
        self.status()
    }
    fn content_length(&self) -> Option<u64> {
        self.content_length()
    }
    fn headers(&self) -> &HeaderMap {
        self.headers()
    }
}
/// Create an HTTP client with default configuration.
pub fn client() -> impl Client {
    static UA: &str = concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"));
    reqwest::Client::builder().user_agent(UA).build().unwrap()
}
#[cfg(any(test, feature = "testing"))]
pub fn mock_client<F>(f: F) -> impl Client
where
    F: Fn(Url) -> ::http::Response<reqwest::Body> + Send + Sync,
{
    struct C<F> {
        respond: F,
    }
    #[async_trait]
    impl<F> Client for C<F>
    where
        F: Fn(Url) -> ::http::Response<reqwest::Body> + Send + Sync,
    {
        type Response = reqwest::Response;
        async fn get<U: IntoUrl>(&self, url: U) -> Result<Self::Response> {
            let url = url.into_url()?;
            Ok(Self::Response::from((self.respond)(url)))
        }
    }
    C { respond: f }
}

[package]
name = "yapma-common"
version = "0.1.0"
authors.workspace = true
license.workspace = true
rust-version.workspace = true
edition.workspace = true
[features]
testing = []
[dependencies]
anyhow.workspace = true
async-trait.workspace = true
http.workspace = true
reqwest.workspace = true
serde.workspace = true
tracing.workspace = true
url.workspace = true

.git
.DS_Store
# Added by cargo
/target
/Cargo.lock

    "lib/common",

http = "0.2.9"

name = "yapma-common"
version = "0.1.0"
dependencies = [
 "anyhow",
 "async-trait",
 "http",
 "reqwest",
 "serde",
 "tracing",
 "url",
]
[[package]]

 "http",

 "yapma-common",