use std::fmt;
use secrecy::{ExposeSecret, SecretString};
use serde::{Deserialize, Serialize};
use crate::consts::CREDENTIAL_SCHEMA_VERSION;
use crate::error::{Error, StorageError};
#[derive(Clone)]
pub struct Session {
token: SecretString,
}
impl Session {
#[must_use]
pub fn from_token(token: impl Into<String>) -> Self {
Session {
token: SecretString::from(token.into()),
}
}
pub fn from_env(var_name: &str) -> Result<Self, Error> {
Self::from_env_value(var_name, std::env::var(var_name).ok())
}
fn from_env_value(var_name: &str, value: Option<String>) -> Result<Self, Error> {
let token =
value.ok_or_else(|| Error::validation(var_name, "environment variable not set"))?;
validate_token_shape(var_name, &token)?;
Ok(Self::from_token(token))
}
#[must_use]
pub fn empty() -> Self {
Session {
token: SecretString::from(String::new()),
}
}
#[must_use]
pub fn is_valid(&self) -> bool {
!self.token.expose_secret().is_empty()
}
#[must_use]
pub fn token(&self) -> &SecretString {
&self.token
}
#[allow(dead_code)]
#[must_use]
pub(crate) fn expose_token(&self) -> &str {
self.token.expose_secret()
}
#[must_use]
pub(crate) fn expose_secret_token(token: &SecretString) -> &str {
token.expose_secret()
}
pub(crate) fn to_stored(&self) -> StoredSession {
StoredSession {
session_id: non_empty(self.token.expose_secret()),
schema_version: Some(CREDENTIAL_SCHEMA_VERSION),
user_token: None,
}
}
pub(crate) fn from_stored(stored: StoredSession) -> (Self, bool) {
let migrated = stored.schema_version.is_none();
let session_id = stored
.session_id
.filter(|s| !s.is_empty())
.or_else(|| stored.user_token.filter(|s| !s.is_empty()));
let token =
session_id.map_or_else(|| SecretString::from(String::new()), SecretString::from);
(Session { token }, migrated)
}
pub(crate) fn to_json(&self) -> Result<String, StorageError> {
let json = serde_json::to_string(&self.to_stored())?;
Ok(json)
}
pub(crate) fn from_json_migrating(json: &str) -> Result<(Self, bool), StorageError> {
let stored: StoredSession = serde_json::from_str(json)?;
Ok(Self::from_stored(stored))
}
pub fn from_json(json: &str) -> Result<Self, StorageError> {
Self::from_json_migrating(json).map(|(session, _migrated)| session)
}
}
impl fmt::Debug for Session {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("Session")
.field("token", &"[REDACTED]")
.finish()
}
}
impl fmt::Display for Session {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
write!(f, "Session {{ valid: {} }}", self.is_valid())
}
}
pub(crate) fn validate_token_shape(field: &str, token: &str) -> Result<(), Error> {
if token.is_empty() {
return Err(Error::validation(field, "must be a non-empty string"));
}
if !token.bytes().all(|b| (0x20..=0x7E).contains(&b)) {
return Err(Error::validation(
field,
"must contain only printable ASCII characters with no CR or LF",
));
}
Ok(())
}
fn non_empty(s: &str) -> Option<String> {
if s.is_empty() {
None
} else {
Some(s.to_owned())
}
}
#[derive(Clone, Serialize, Deserialize)]
pub struct StoredSession {
session_id: Option<String>,
#[serde(default)]
schema_version: Option<u32>,
#[serde(default, skip_serializing)]
user_token: Option<String>,
}
impl fmt::Debug for StoredSession {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("StoredSession")
.field(
"session_id",
&self.session_id.as_ref().map(|_| "[REDACTED]"),
)
.field("schema_version", &self.schema_version)
.field(
"user_token",
&self.user_token.as_ref().map(|_| "[REDACTED]"),
)
.finish()
}
}
#[cfg(test)]
mod tests {
use super::{Error, Session, StoredSession, validate_token_shape};
#[test]
fn round_trip_matches_v8_0_4_wire_shape() {
let json = r#"{"session_id":"tok-123","schema_version":2}"#;
let session = Session::from_json(json).expect("valid json parses");
assert_eq!(session.expose_token(), "tok-123");
let round_tripped = session.to_json().expect("session serializes");
assert_eq!(round_tripped, json);
}
#[test]
fn empty_session_round_trips_to_a_null_session_id() {
let session = Session::empty();
let json = session.to_json().expect("serializes");
assert_eq!(json, r#"{"session_id":null,"schema_version":2}"#);
let restored = Session::from_json(&json).expect("parses");
assert!(!restored.is_valid());
assert_eq!(restored.expose_token(), "");
}
#[test]
fn record_without_schema_version_is_reported_as_migrated() {
let json = r#"{"session_id":"tok-123"}"#;
let (session, migrated) = Session::from_json_migrating(json).expect("valid json parses");
assert_eq!(session.expose_token(), "tok-123");
assert!(migrated, "no schema_version key means a legacy record");
}
#[test]
fn record_with_schema_version_is_not_migrated() {
let json = r#"{"session_id":"tok-123","schema_version":2}"#;
let (_, migrated) = Session::from_json_migrating(json).expect("valid json parses");
assert!(!migrated);
}
#[test]
fn legacy_user_token_key_is_accepted_as_session_id_alias() {
let json = r#"{"user_token":"old_token_123","session_id":null}"#;
let (session, migrated) = Session::from_json_migrating(json).expect("valid json parses");
assert_eq!(session.expose_token(), "old_token_123");
assert!(migrated);
}
#[test]
fn empty_session_id_still_falls_back_to_user_token() {
let json = r#"{"session_id":"","user_token":"old_token_123"}"#;
let (session, _) = Session::from_json_migrating(json).expect("valid json parses");
assert_eq!(session.expose_token(), "old_token_123");
}
#[test]
fn present_session_id_wins_over_user_token() {
let json = r#"{"session_id":"new-token","user_token":"old-token"}"#;
let (session, _) = Session::from_json_migrating(json).expect("valid json parses");
assert_eq!(session.expose_token(), "new-token");
}
#[test]
fn legacy_refresh_token_and_session_expiry_fields_are_silently_dropped() {
let json =
r#"{"session_id":"tok","refresh_token":"rt-1","session_expiry":"2099-01-01T00:00:00"}"#;
let (session, migrated) = Session::from_json_migrating(json).expect("valid json parses");
assert_eq!(session.expose_token(), "tok");
assert!(migrated);
let reserialized = session.to_json().expect("serializes");
assert!(!reserialized.contains("refresh_token"));
assert!(!reserialized.contains("session_expiry"));
}
#[test]
fn empty_session_is_never_valid() {
assert!(!Session::empty().is_valid());
}
#[test]
fn from_token_produces_a_valid_session() {
let session = Session::from_token("tok");
assert!(session.is_valid());
}
#[test]
fn is_valid_true_regardless_of_any_wall_clock_state() {
let session = Session::from_token("tok");
assert!(session.is_valid());
assert!(session.is_valid(), "still valid on a second check");
}
#[test]
fn debug_never_prints_the_token() {
let session = Session::from_token("super-secret-token");
let debug = format!("{session:?}");
assert!(!debug.contains("super-secret-token"));
}
#[test]
fn display_never_prints_the_token() {
let session = Session::from_token("super-secret-token");
let display = format!("{session}");
assert!(!display.contains("super-secret-token"));
}
#[test]
fn stored_session_debug_never_prints_session_id_or_user_token() {
let stored = StoredSession {
session_id: Some("super-secret-session-id".to_owned()),
schema_version: Some(2),
user_token: Some("super-secret-user-token".to_owned()),
};
let debug = format!("{stored:?}");
assert!(!debug.contains("super-secret-session-id"));
assert!(!debug.contains("super-secret-user-token"));
assert!(
debug.contains('2'),
"schema_version is not a secret: {debug}"
);
assert!(debug.contains("REDACTED"));
}
#[test]
fn validate_token_shape_rejects_empty() {
let err = validate_token_shape("token", "").unwrap_err();
assert!(matches!(err, Error::Validation { field, message, .. }
if field == "token" && message == "must be a non-empty string"));
}
#[test]
fn validate_token_shape_rejects_control_characters() {
let err = validate_token_shape("token", "tok\nwith-newline").unwrap_err();
assert!(matches!(err, Error::Validation { field, .. } if field == "token"));
}
#[test]
fn validate_token_shape_accepts_printable_ascii() {
validate_token_shape("token", "tok-123_ABC.").expect("printable ascii is accepted");
}
#[test]
fn from_env_value_missing_is_validation_error() {
let err = Session::from_env_value("RUSTEERO_TEST_TOKEN", None).unwrap_err();
assert!(matches!(err, Error::Validation { .. }));
}
#[test]
fn from_env_value_empty_is_validation_error() {
let err = Session::from_env_value("RUSTEERO_TEST_TOKEN", Some(String::new())).unwrap_err();
assert!(matches!(err, Error::Validation { .. }));
}
#[test]
fn from_env_value_non_ascii_is_validation_error() {
let err =
Session::from_env_value("RUSTEERO_TEST_TOKEN", Some("tok\r\n".to_owned())).unwrap_err();
assert!(matches!(err, Error::Validation { .. }));
}
#[test]
fn from_env_value_success_builds_a_valid_session() {
let session = Session::from_env_value("RUSTEERO_TEST_TOKEN", Some("tok".to_owned()))
.expect("non-empty value is accepted");
assert!(session.is_valid());
assert_eq!(session.expose_token(), "tok");
}
#[test]
fn from_env_missing_variable_returns_validation_error() {
let err = Session::from_env("RUSTEERO_SESSION_STORE_TEST_VAR_DOES_NOT_EXIST")
.expect_err("variable is not set");
assert!(
matches!(err, Error::Validation { field, .. } if field == "RUSTEERO_SESSION_STORE_TEST_VAR_DOES_NOT_EXIST")
);
}
}