use std::sync::Arc;
use secrecy::{ExposeSecret, SecretString};
use serde_json::{Value, json};
use crate::auth::Session;
use crate::consts;
use crate::envelope::Envelope;
use crate::error::Error;
use crate::routes;
use crate::transport::{RequestBody, Transport};
const LOGIN_FAILED_NO_USER_TOKEN: &str = "Login failed: No user token received";
#[derive(Debug)]
pub struct LoginFlow {
transport: Arc<Transport>,
}
impl LoginFlow {
pub fn new(http_builder: Option<reqwest::ClientBuilder>) -> Result<Self, Error> {
let mut builder = Transport::builder();
if let Some(http_builder) = http_builder {
builder = builder.http_builder(http_builder);
}
Ok(Self {
transport: Arc::new(builder.build()?),
})
}
#[must_use]
pub fn with_transport(transport: Transport) -> Self {
Self {
transport: Arc::new(transport),
}
}
pub async fn start(&self, user_identifier: &str) -> Result<PendingLogin, Error> {
let url = routes::LOGIN.resolve(self.transport.api_host(), "", None)?;
let body = RequestBody::Form(login_request_body(user_identifier));
let envelope = self
.transport
.request_with_token(reqwest::Method::POST, url, &[], body, None)
.await
.map_err(|err| wrap_as_authentication("Login", true, err))?;
let login_token = extract_user_token(&envelope)?;
Ok(PendingLogin {
login_token,
transport: Arc::clone(&self.transport),
})
}
}
pub struct PendingLogin {
login_token: SecretString,
transport: Arc<Transport>,
}
impl PendingLogin {
pub async fn resend(&self) -> Result<Envelope, Error> {
let url = routes::LOGIN_RESEND.resolve(self.transport.api_host(), "", None)?;
self.transport
.request_with_token(
reqwest::Method::POST,
url,
&[],
RequestBody::Json(json!({})),
Some(&self.login_token),
)
.await
}
pub async fn verify(self, code: &str) -> Result<Session, Error> {
let url = routes::LOGIN_VERIFY.resolve(self.transport.api_host(), "", None)?;
let body = RequestBody::Form(verify_request_body(code));
self.transport
.request_with_token(
reqwest::Method::POST,
url,
&[],
body,
Some(&self.login_token),
)
.await
.map_err(|err| wrap_as_authentication("Verification", false, err))?;
Ok(Session::from_token(self.login_token.expose_secret()))
}
#[allow(dead_code)]
#[must_use]
pub(crate) fn user_token(&self) -> &SecretString {
&self.login_token
}
}
impl std::fmt::Debug for PendingLogin {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.debug_struct("PendingLogin")
.field("login_token", &"[REDACTED]")
.finish_non_exhaustive()
}
}
fn wrap_as_authentication(prefix: &str, wrap_validation: bool, err: Error) -> Error {
match err {
Error::Api { .. }
| Error::AccessDenied { .. }
| Error::ClientBlocked { .. }
| Error::NotFound { .. }
| Error::PremiumRequired { .. }
| Error::FeatureUnavailable { .. } => wrap(prefix, &err),
Error::Validation { .. } if wrap_validation => wrap(prefix, &err),
other => other,
}
}
fn wrap(prefix: &str, other: &Error) -> Error {
let envelope = other.envelope().cloned();
let error_code = other.error_code().map(str::to_owned);
let message = format!("{prefix} failed: {other}");
Error::Authentication {
message,
envelope,
error_code,
}
}
fn login_request_body(user_identifier: &str) -> Vec<(String, String)> {
vec![("login".to_owned(), user_identifier.to_owned())]
}
fn verify_request_body(code: &str) -> Vec<(String, String)> {
vec![("code".to_owned(), code.to_owned())]
}
fn extract_user_token(envelope: &Envelope) -> Result<SecretString, Error> {
envelope
.data()
.get(consts::USER_TOKEN_KEY)
.and_then(Value::as_str)
.filter(|token| !token.is_empty())
.map(|token| SecretString::from(token.to_owned()))
.ok_or_else(|| Error::authentication(LOGIN_FAILED_NO_USER_TOKEN))
}
#[cfg(test)]
mod tests {
use secrecy::{ExposeSecret, SecretString};
use serde_json::json;
use super::{
LoginFlow, PendingLogin, extract_user_token, login_request_body, verify_request_body,
wrap_as_authentication,
};
use crate::envelope::Envelope;
use crate::error::Error;
use crate::transport::Transport;
#[test]
fn login_request_body_matches_the_form_shape() {
assert_eq!(
login_request_body("user@example.com"),
vec![("login".to_owned(), "user@example.com".to_owned())]
);
}
#[test]
fn verify_request_body_matches_the_form_shape() {
assert_eq!(
verify_request_body("123456"),
vec![("code".to_owned(), "123456".to_owned())]
);
}
#[test]
fn extract_user_token_reads_data_user_token() {
let envelope = Envelope::from_value(json!({ "data": { "user_token": "ut-123" } }));
let token = extract_user_token(&envelope).expect("token present");
assert_eq!(token.expose_secret(), "ut-123");
}
#[test]
fn extract_user_token_missing_is_authentication_error_with_the_expected_message() {
let envelope = Envelope::from_value(json!({ "data": {} }));
let err = extract_user_token(&envelope).unwrap_err();
assert!(
matches!(err, Error::Authentication { message: ref msg, .. } if msg == "Login failed: No user token received")
);
}
#[test]
fn extract_user_token_empty_string_is_authentication_error() {
let envelope = Envelope::from_value(json!({ "data": { "user_token": "" } }));
assert!(extract_user_token(&envelope).is_err());
}
#[test]
fn extract_user_token_no_data_key_at_all_is_authentication_error() {
let envelope = Envelope::from_value(json!({}));
assert!(extract_user_token(&envelope).is_err());
}
#[test]
fn wrap_as_authentication_leaves_a_401_unchanged() {
let original = Error::authentication("some 401 message");
let wrapped = wrap_as_authentication("Login", true, original);
assert!(
matches!(wrapped, Error::Authentication { message, .. } if message == "some 401 message")
);
}
#[test]
fn wrap_as_authentication_wraps_a_validation_error_with_the_prefix() {
let original = Error::validation("request", "error.form.errors");
let wrapped = wrap_as_authentication("Login", true, original);
match wrapped {
Error::Authentication { message, .. } => {
assert_eq!(
message,
"Login failed: Validation error for 'request': error.form.errors"
);
}
other => panic!("expected Error::Authentication, got {other:?}"),
}
}
#[test]
fn wrap_as_authentication_leaves_a_rate_limit_unchanged() {
let original = Error::RateLimit {
message: "error.rate.limit".to_owned(),
retry_after: None,
envelope: None,
error_code: Some("error.rate.limit".to_owned()),
};
assert!(matches!(
wrap_as_authentication("Login", true, original),
Error::RateLimit { .. }
));
}
#[test]
fn wrap_as_authentication_leaves_a_validation_error_unchanged_for_verify() {
let original = Error::validation("request", "error.form.errors");
assert!(matches!(
wrap_as_authentication("Verification", false, original),
Error::Validation { .. }
));
}
#[test]
fn wrap_as_authentication_leaves_network_and_timeout_unchanged() {
assert!(matches!(
wrap_as_authentication("Verification", false, Error::Timeout),
Error::Timeout
));
}
#[test]
fn pending_login_debug_never_prints_the_login_token() {
let transport = Transport::builder().build().expect("builds with defaults");
let pending = PendingLogin {
login_token: SecretString::from("super-secret-login-token".to_owned()),
transport: std::sync::Arc::new(transport),
};
let debug = format!("{pending:?}");
assert!(!debug.contains("super-secret-login-token"));
assert!(debug.contains("REDACTED"));
}
#[test]
fn login_flow_new_builds_without_any_store_or_client() {
let flow = LoginFlow::new(None).expect("builds with defaults, no store required");
assert!(flow.transport.session().is_none());
}
#[test]
fn login_flow_with_transport_needs_no_store() {
let transport = Transport::builder().build().expect("builds with defaults");
let flow = LoginFlow::with_transport(transport);
assert!(!flow.transport.is_authenticated());
}
}