use axum::body::Body;
use axum::http::request::Parts;
use axum::http::{Extensions, Request};
use super::TenantSlug;
#[derive(Clone, Debug, PartialEq, Eq)]
#[non_exhaustive]
pub enum RequestTenant {
Global,
Tenant(TenantSlug),
Unmatched,
Unknown,
}
impl RequestTenant {
#[must_use]
pub fn get(extensions: &Extensions) -> Option<&Self> {
extensions.get::<Self>()
}
pub async fn resolve(parts: &mut Parts) -> Self {
if let Some(t) = Self::get(&parts.extensions) {
return t.clone();
}
if let Some(t) = parts.extensions.get::<TenantSlug>() {
return Self::Tenant(t.clone());
}
let Some(found) = super::middleware::request_org(parts, &parts.extensions).await else {
return Self::Global;
};
if let Err(e) = &found {
tracing::warn!(target: "rustango::tenancy", error = %e, "tenant resolution failed");
}
let tenant = Self::from_resolution(found);
parts.extensions.insert(tenant.clone());
tenant
}
pub(crate) async fn resolve_request(req: Request<Body>) -> (Request<Body>, Self) {
let (mut parts, body) = req.into_parts();
let tenant = Self::resolve(&mut parts).await;
(Request::from_parts(parts, body), tenant)
}
pub(crate) fn from_resolution<E>(found: Result<Option<super::Org>, E>) -> Self {
match found {
Ok(Some(org)) => TenantSlug::of(&org).map_or(Self::Unknown, Self::Tenant),
Ok(None) => Self::Unmatched,
Err(_) => Self::Unknown,
}
}
pub(crate) fn unmounted(extensions: &Extensions) -> bool {
Self::get(extensions).is_none()
&& extensions.get::<TenantSlug>().is_none()
&& crate::extractors::MountedTenantContext::of(extensions).is_none()
}
#[must_use]
pub fn tenant(&self) -> Option<&TenantSlug> {
match self {
Self::Tenant(t) => Some(t),
Self::Global | Self::Unmatched | Self::Unknown => None,
}
}
}
#[cfg(test)]
mod tests {
use super::*;
fn parts() -> Parts {
Request::builder().body(()).unwrap().into_parts().0
}
#[tokio::test]
async fn no_context_is_global_and_not_stored() {
let mut p = parts();
assert_eq!(RequestTenant::resolve(&mut p).await, RequestTenant::Global);
assert!(RequestTenant::get(&p.extensions).is_none());
assert!(RequestTenant::unmounted(&p.extensions));
}
#[tokio::test]
async fn a_stored_answer_wins_over_a_bound_credential() {
let mut p = parts();
p.extensions.insert(TenantSlug::new(2, "globex"));
p.extensions.insert(RequestTenant::Unknown);
assert_eq!(RequestTenant::resolve(&mut p).await, RequestTenant::Unknown);
assert!(!RequestTenant::unmounted(&p.extensions));
}
#[test]
fn an_org_without_an_id_is_unknown() {
let org = crate::tenancy::Org {
slug: "acme".into(),
..crate::testkit::org()
};
assert_eq!(
RequestTenant::from_resolution::<()>(Ok(Some(org))),
RequestTenant::Unknown
);
assert_eq!(
RequestTenant::from_resolution::<()>(Ok(None)),
RequestTenant::Unmatched
);
assert_eq!(
RequestTenant::from_resolution(Err(())),
RequestTenant::Unknown
);
}
}