Struct OAuthAuth 

pub struct OAuthAuth {
    pub grant_type: OAuthGrantType,
    pub token_url: String,
    pub client_id: String,
    pub client_secret: Option<String>,
    pub scope: Option<String>,
    pub username: Option<String>,
    pub password: Option<String>,
    pub authorization_url: Option<String>,
    pub redirect_uri: Option<String>,
}

Auth::oauth: acquire a bearer token from an OAuth token endpoint before the request is sent, under one of three grants.

auth:
  oauth:
    grant_type: client_credentials   # or: password, authorization_code
    token_url: https://auth.example.com/token
    client_id: {{client_id}}
    client_secret: {{client_secret}}
    scope: read write                 # optional
    # required only for grant_type: password
    username: {{username}}
    password: {{password}}
    # required only for grant_type: authorization_code
    authorization_url: https://auth.example.com/authorize
    redirect_uri: http://127.0.0.1:8899/callback

client_credentials and password are acquired automatically — crate::Request::resolve_oauth fetches (or reuses a cached) token before every send with no human involved. authorization_code cannot work that way: it needs a human to approve access in a browser, so resolve_oauth refuses to attempt it automatically and instead reports a clear error directing the caller to log in interactively first. The TUI is the one caller that can do that — see crate::oauth’s module docs for the interactive flow and why client_secret is optional only for this grant (a desktop client cannot keep a secret confidential, so PKCE stands in for it; see RFC 8252 §8.1/§8.5).

crate::Request::resolve_oauth acquires the token — through crate::oauth::OAuthTokenCache, reusing one already acquired for the same token_url/client_id/grant_type/scope within this run rather than re-authenticating per request — and hands it to the exact same Authorization: Bearer code path Auth::bearer already resolves to; see crate::Request::resolve_auth.

Fields

grant_type: OAuthGrantType

token_url: String

client_id: String

client_secret: Option<String>

Required for OAuthGrantType::ClientCredentials and OAuthGrantType::Password; optional for OAuthGrantType::AuthorizationCode, whose native/desktop clients typically have none — see validate_grant_fields.

scope: Option<String>

username: Option<String>

Required when grant_type is OAuthGrantType::Password — see validate_grant_fields.

password: Option<String>

Required when grant_type is OAuthGrantType::Password — see validate_grant_fields.

authorization_url: Option<String>

The provider’s authorization endpoint — where the browser is sent to let the user approve access. Required when grant_type is OAuthGrantType::AuthorizationCode; unused by the other two grants, which never open a browser. See validate_grant_fields.

redirect_uri: Option<String>

Where the provider redirects back with the authorization code — must match what is registered with the provider. Required when grant_type is OAuthGrantType::AuthorizationCode; the TUI’s local callback listener binds to this exact address. See validate_grant_fields.

Trait Implementations

impl Clone for OAuthAuth

fn clone(&self) -> OAuthAuth

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OAuthAuth

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OAuthAuth

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for OAuthAuth

impl PartialEq for OAuthAuth

fn eq(&self, other: &OAuthAuth) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for OAuthAuth

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for OAuthAuth