use serde::{Deserialize, Serialize};
use uuid::Uuid;
use crate::AxiamError;
use crate::client::{AxiamClient, OrgIdentifier, TenantIdentifier};
use crate::rest::auth::CsrfHeaderExt;
use super::exchange::{SsoCompleteResult, SsoStartResult, network_err};
pub const SSO_PROVIDERS_PATH: &str = "/api/v1/auth/federation/providers";
pub const SSO_OAUTH2_START_PATH: &str = "/api/v1/auth/federation/oauth2/start";
pub const SSO_OAUTH2_CALLBACK_PATH: &str = "/api/v1/auth/federation/oauth2/callback";
pub const SSO_HANDOFF_PATH: &str = "/api/v1/auth/federation/handoff";
pub const HANDOFF_QUERY_PARAM: &str = "axiam_handoff";
pub const HANDOFF_CODE_TTL_SECS: u64 = 60;
pub const PROTOCOL_OIDC_CONNECT: &str = "OidcConnect";
pub const PROTOCOL_OAUTH2: &str = "OAuth2";
pub const PROTOCOL_SAML: &str = "Saml";
#[derive(Debug, Deserialize)]
struct PublicFederationProviderWire {
id: Uuid,
provider_kind: String,
display_name: String,
protocol: String,
has_bundled_mark: bool,
inherited: bool,
#[serde(default)]
button_icon: Option<String>,
}
#[derive(Debug, Deserialize)]
struct PublicFederationProvidersResponseWire {
providers: Vec<PublicFederationProviderWire>,
}
#[derive(Serialize)]
struct OAuth2StartRequestWire {
federation_config_id: String,
redirect_uri: String,
#[serde(skip_serializing_if = "Option::is_none")]
tenant_id: Option<Uuid>,
#[serde(skip_serializing_if = "Option::is_none")]
tenant_slug: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
org_id: Option<Uuid>,
#[serde(skip_serializing_if = "Option::is_none")]
org_slug: Option<String>,
}
#[derive(Debug, Deserialize)]
struct OAuth2StartResponseWire {
authorize_url: String,
state: String,
expires_in_secs: u64,
}
#[derive(Serialize)]
struct OAuth2CallbackRequestWire<'a> {
state: &'a str,
code: &'a str,
}
#[derive(Serialize)]
struct SsoHandoffRequestWire<'a> {
code: &'a str,
}
#[derive(Debug, Deserialize)]
struct SsoLoginSuccessResponseWire {
user_id: Uuid,
session_id: Uuid,
expires_in: u64,
redirect_uri: String,
}
#[derive(Debug, Clone)]
pub struct FederationProvider {
pub id: Uuid,
pub provider_kind: String,
pub display_name: String,
pub protocol: String,
pub has_bundled_mark: bool,
pub inherited: bool,
pub button_icon: Option<String>,
}
#[derive(Debug, Clone)]
pub struct FederationProviderList {
pub providers: Vec<FederationProvider>,
}
#[derive(Debug, Clone, Default)]
pub struct SsoProvidersParams {
pub org_id: Option<Uuid>,
pub org_slug: Option<String>,
pub tenant_id: Option<Uuid>,
pub tenant_slug: Option<String>,
}
#[derive(Debug, Clone, Default)]
pub struct SsoStartOauth2Params {
pub federation_config_id: String,
pub redirect_uri: String,
pub tenant_id: Option<Uuid>,
pub tenant_slug: Option<String>,
pub org_id: Option<Uuid>,
pub org_slug: Option<String>,
}
#[derive(Debug, Clone, Default)]
pub struct SsoCompleteOauth2Params {
pub state: String,
pub code: String,
}
#[derive(Debug, Clone, Default)]
pub struct SsoCompleteHandoffParams {
pub code: String,
}
impl AxiamClient {
fn federation_tenant_pair(
&self,
tenant_id: Option<Uuid>,
tenant_slug: Option<String>,
) -> (Option<Uuid>, Option<String>) {
match (tenant_id, tenant_slug) {
(Some(id), _) => (Some(id), None),
(None, Some(slug)) => (None, Some(slug)),
(None, None) => match &self.inner.tenant {
TenantIdentifier::Id(id) => (Some(*id), None),
TenantIdentifier::Slug(slug) => (None, Some(slug.clone())),
},
}
}
fn federation_org_pair(
&self,
org_id: Option<Uuid>,
org_slug: Option<String>,
) -> (Option<Uuid>, Option<String>) {
match (org_id, org_slug) {
(Some(id), _) => (Some(id), None),
(None, Some(slug)) => (None, Some(slug)),
(None, None) => match self.org_identifier() {
Some(OrgIdentifier::Id(id)) => (Some(*id), None),
Some(OrgIdentifier::Slug(slug)) => (None, Some(slug.clone())),
None => (self.resolved_org_id(), None),
},
}
}
pub async fn sso_providers(
&self,
params: SsoProvidersParams,
) -> Result<FederationProviderList, AxiamError> {
let (tenant_id, tenant_slug) =
self.federation_tenant_pair(params.tenant_id, params.tenant_slug);
let (org_id, org_slug) = self.federation_org_pair(params.org_id, params.org_slug);
let mut url = self
.base_url()
.join(SSO_PROVIDERS_PATH)
.expect("sso_providers path is a well-formed relative URL literal");
{
let mut query = url.query_pairs_mut();
if let Some(id) = org_id {
query.append_pair("org_id", &id.to_string());
}
if let Some(slug) = org_slug.as_deref() {
query.append_pair("org_slug", slug);
}
if let Some(id) = tenant_id {
query.append_pair("tenant_id", &id.to_string());
}
if let Some(slug) = tenant_slug.as_deref() {
query.append_pair("tenant_slug", slug);
}
}
let response = self
.http()
.get(url)
.header("X-Tenant-ID", self.tenant_header_value())
.send()
.await
.map_err(|e| network_err("sso_providers request failed", e))?;
if !response.status().is_success() {
let status = response.status().as_u16();
let message = response
.text()
.await
.unwrap_or_else(|_| "no response body".to_string());
return Err(AxiamError::from_http_status(status, message));
}
let wire: PublicFederationProvidersResponseWire = response
.json()
.await
.map_err(|e| network_err("failed to parse sso_providers response", e))?;
Ok(FederationProviderList {
providers: wire
.providers
.into_iter()
.map(|p| FederationProvider {
id: p.id,
provider_kind: p.provider_kind,
display_name: p.display_name,
protocol: p.protocol,
has_bundled_mark: p.has_bundled_mark,
inherited: p.inherited,
button_icon: p.button_icon,
})
.collect(),
})
}
pub async fn sso_start_oauth2(
&self,
params: SsoStartOauth2Params,
) -> Result<SsoStartResult, AxiamError> {
let (tenant_id, tenant_slug) =
self.federation_tenant_pair(params.tenant_id, params.tenant_slug);
let (org_id, org_slug) = self.federation_org_pair(params.org_id, params.org_slug);
if org_id.is_none() && org_slug.is_none() {
return Err(AxiamError::auth(
"sso_start_oauth2 requires organization context: pass org_id or org_slug, or \
construct the client with one (CONTRACT.md §5.1)",
));
}
let body = OAuth2StartRequestWire {
federation_config_id: params.federation_config_id,
redirect_uri: params.redirect_uri,
tenant_id,
tenant_slug,
org_id,
org_slug,
};
let url = self
.base_url()
.join(SSO_OAUTH2_START_PATH)
.expect("sso_start_oauth2 path is a well-formed relative URL literal");
let response = self
.http()
.post(url)
.header("X-Tenant-ID", self.tenant_header_value())
.maybe_csrf_header(self)
.json(&body)
.send()
.await
.map_err(|e| network_err("sso_start_oauth2 request failed", e))?;
if !response.status().is_success() {
let status = response.status().as_u16();
let message = response
.text()
.await
.unwrap_or_else(|_| "no response body".to_string());
return Err(AxiamError::from_http_status(status, message));
}
let wire: OAuth2StartResponseWire = response
.json()
.await
.map_err(|e| network_err("failed to parse sso_start_oauth2 response", e))?;
Ok(SsoStartResult {
authorize_url: wire.authorize_url,
state: wire.state,
expires_in_secs: wire.expires_in_secs,
})
}
pub async fn sso_complete_oauth2(
&self,
params: SsoCompleteOauth2Params,
) -> Result<SsoCompleteResult, AxiamError> {
let body = OAuth2CallbackRequestWire {
state: ¶ms.state,
code: ¶ms.code,
};
let url = self
.base_url()
.join(SSO_OAUTH2_CALLBACK_PATH)
.expect("sso_complete_oauth2 path is a well-formed relative URL literal");
self.post_federation_session(url, &body, "sso_complete_oauth2")
.await
}
pub async fn sso_complete_handoff(
&self,
params: SsoCompleteHandoffParams,
) -> Result<SsoCompleteResult, AxiamError> {
let body = SsoHandoffRequestWire { code: ¶ms.code };
let url = self
.base_url()
.join(SSO_HANDOFF_PATH)
.expect("sso_complete_handoff path is a well-formed relative URL literal");
self.post_federation_session(url, &body, "sso_complete_handoff")
.await
}
async fn post_federation_session<B: Serialize + ?Sized>(
&self,
url: url::Url,
body: &B,
operation: &str,
) -> Result<SsoCompleteResult, AxiamError> {
let response = self
.http()
.post(url)
.header("X-Tenant-ID", self.tenant_header_value())
.maybe_csrf_header(self)
.json(body)
.send()
.await
.map_err(|e| network_err(&format!("{operation} request failed"), e))?;
if !response.status().is_success() {
let status = response.status().as_u16();
let message = response
.text()
.await
.unwrap_or_else(|_| "no response body".to_string());
return Err(AxiamError::from_http_status(status, message));
}
let wire: SsoLoginSuccessResponseWire = response
.json()
.await
.map_err(|e| network_err(&format!("failed to parse {operation} response"), e))?;
crate::rest::auth::absorb_session_cookies(self).await?;
Ok(SsoCompleteResult {
user_id: wire.user_id,
session_id: wire.session_id,
expires_in: wire.expires_in,
redirect_uri: wire.redirect_uri,
})
}
}