OAuth 2.1 Клиент

use volga_oauth_client::{ClientError, DiscoveryClient};

async fn discover() -> Result<(), ClientError> {
    let client = DiscoveryClient::new();

    // напрямую по идентификатору эмитента (RFC 8414 или путь OIDC):
    let server = client.fetch_server_metadata("https://auth.example.com").await?;

    // или начиная с ресурса и следуя к его серверу авторизации:
    let resource = client.fetch_resource_metadata("https://api.example.com").await?;
    let server = client.discover_authorization_server(&resource).await?;

    assert!(server.token_endpoint.is_some());
    Ok(())
}

use std::sync::Arc;
use volga_oauth_client::{ClientError, DiscoveryClient, InMemoryTokenStore, OAuthClient};

async fn authorize() -> Result<(), ClientError> {
    let metadata = DiscoveryClient::new()
        .fetch_server_metadata("https://auth.example.com")
        .await?;

    let client = OAuthClient::new("my-client")
        .with_redirect_uri("https://app.example.com/callback")
        .with_token_store(Arc::new(InMemoryTokenStore::new()));

    // 1. строим запрос авторизации (state и PKCE генерируются)
    let auth = client
        .authorization_request(&metadata)
        .with_scopes(["read"])
        .with_resource("https://api.example.com")
        .build()?;

    // 2. отправляем пользователя на `auth.url`. Провайдер редиректит обратно
    //    на ваш callback с настоящими query-параметрами `code` и `state` —
    //    их и читаем там. (В этом примере переиспользуется сгенерированный
    //    `auth.state`, чтобы проверка ниже проходила на «счастливом пути».)
    let (code, state) = ("the-authorization-code", auth.state.as_str());

    // всегда проверяйте state из callback до обмена — защита от CSRF
    if !auth.matches_state(state) {
        return Ok(()); // отклоняем — возможен CSRF
    }

    // 3. обмениваем код на токены (verifier PKCE идёт вместе с запросом)
    let tokens = client.exchange_code(&metadata, code, &auth).await?;
    client.store_tokens("alice", &tokens);

    // 4. позже — отдаётся из хранилища, прозрачно обновляется при устаревании:
    let tokens = client.token("alice", &metadata).await?;
    Ok(())
}

use volga_oauth_client::{ClientAuthMethod, OAuthClient};

let client = OAuthClient::new("my-client")
    .with_secret("s3cret")
    // `client_secret_basic` (по-умолчанию) или `client_secret_post`
    .with_auth_method(ClientAuthMethod::Post);

use volga_oauth_client::{TokenSet, TokenStore};

struct MyStore;

impl TokenStore for MyStore {
    fn get(&self, key: &str) -> Option<TokenSet> { /* ... */ None }
    fn put(&self, key: &str, tokens: &TokenSet) { /* ... */ }
    fn remove(&self, key: &str) { /* ... */ }
}

use volga_oauth_client::{
    ClientError, ClientMetadata, DiscoveryClient, OAuthClient, RegistrationClient,
};

async fn register() -> Result<(), ClientError> {
    let metadata = DiscoveryClient::new()
        .fetch_server_metadata("https://auth.example.com")
        .await?;

    let registered = RegistrationClient::new()
        .register(
            &metadata,
            &ClientMetadata::new()
                .with_redirect_uris(["https://app.example.com/callback"])
                .with_client_name("My App"),
        )
        .await?;

    // готовый к использованию клиент с выданными учётными данными
    let client = OAuthClient::from_registration(&registered)?;
    Ok(())
}

use std::time::Duration;
use volga_oauth_client::{ClientConfig, OAuthClient};

let config = ClientConfig::new()
    .require_https(false)              // только для локальной разработки
    .with_timeout(Duration::from_secs(5))
    .with_max_redirects(0);

let client = OAuthClient::new("my-client").with_config(config);