use serde::{Deserialize, Serialize};
pub use crate::stp::LoginParams;
pub use crate::session::TokenInfo;
pub type SessionData = crate::session::TokenSession;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CheckLoginRequest {
pub token: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CheckPermissionRequest {
pub token: String,
pub permission: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CheckRoleRequest {
pub token: String,
pub role: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct CheckApiKeyRequest {
pub api_key: String,
pub namespace: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct KickoutRequest {
pub login_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LoginRequest {
#[serde(deserialize_with = "validate_login_id_field")]
pub login_id: String,
pub params: LoginParams,
}
fn validate_login_id_field<'de, D>(deserializer: D) -> Result<String, D::Error>
where
D: serde::Deserializer<'de>,
{
let value = String::deserialize(deserializer)?;
let max_len = crate::config::DEFAULT_LOGIN_ID_MAX_LEN as usize;
let rejection = if value.is_empty() || value.trim().is_empty() {
Some("login_id must not be empty or whitespace-only (stp-login-id-empty)")
} else if value.contains('\x1f') {
Some("login_id must not contain the unit separator (stp-login-id-sep)")
} else if value.chars().any(|c| c.is_control()) {
Some("login_id must not contain control characters (stp-login-id-control-char)")
} else if value.len() > max_len {
Some("login_id exceeds the maximum length (stp-login-id-too-long)")
} else {
None
};
match rejection {
Some(msg) => Err(serde::de::Error::custom(msg)),
None => Ok(value),
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct LogoutRequest {
pub token: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SwitchToRequest {
pub token: String,
pub target_login_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct RenewToEquivalentRequest {
pub token: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ApiResponse<T> {
#[serde(skip_serializing_if = "Option::is_none")]
pub data: Option<T>,
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
impl<T> ApiResponse<T> {
pub fn ok(data: T) -> Self {
Self {
data: Some(data),
error_code: None,
message: None,
}
}
pub fn err(error_code: impl Into<String>, message: impl Into<String>) -> Self {
Self {
data: None,
error_code: Some(error_code.into()),
message: Some(message.into()),
}
}
pub fn into_result(self) -> Result<T, (String, String)> {
if let Some(code) = self.error_code {
return Err((
code,
self.message
.unwrap_or_else(|| "backend-unknown-error::".to_string()),
));
}
match self.data {
Some(v) => Ok(v),
None => Err(("UNKNOWN".to_string(), "backend-unknown-error::".to_string())),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn api_response_ok_wraps_data() {
let resp: ApiResponse<i32> = ApiResponse::ok(42);
assert_eq!(resp.data, Some(42));
assert!(resp.error_code.is_none());
assert!(resp.message.is_none());
}
#[test]
fn api_response_err_wraps_error_info() {
let resp: ApiResponse<String> = ApiResponse::err("DENIED", "拒绝访问");
assert!(resp.data.is_none());
assert_eq!(resp.error_code.as_deref(), Some("DENIED"));
assert_eq!(resp.message.as_deref(), Some("拒绝访问"));
}
#[test]
fn into_result_ok_extracts_data() {
let resp: ApiResponse<i32> = ApiResponse::ok(7);
assert_eq!(resp.into_result().unwrap(), 7);
}
#[test]
fn into_result_err_with_explicit_fields() {
let resp: ApiResponse<i32> = ApiResponse::err("NOT_FOUND", "资源不存在");
let (code, msg) = resp.into_result().unwrap_err();
assert_eq!(code, "NOT_FOUND");
assert_eq!(msg, "资源不存在");
}
#[test]
fn into_result_err_with_none_fields_uses_defaults() {
let resp: ApiResponse<i32> = ApiResponse {
data: None,
error_code: None,
message: None,
};
let (code, msg) = resp.into_result().unwrap_err();
assert_eq!(code, "UNKNOWN");
assert_eq!(msg, "backend-unknown-error::");
}
#[test]
fn into_result_error_takes_precedence_over_data() {
let resp: ApiResponse<i32> = ApiResponse {
data: Some(42),
error_code: Some("INVALID_TOKEN".to_string()),
message: Some("token 已过期".to_string()),
};
let (code, msg) = resp.into_result().unwrap_err();
assert_eq!(code, "INVALID_TOKEN");
assert_eq!(msg, "token 已过期");
}
fn deser_login_request(body: &str) -> Result<LoginRequest, serde_json::Error> {
serde_json::from_str(body)
}
fn login_body(login_id_json: &str) -> String {
format!(
r#"{{"login_id":{},"params":{{"remember_me":false,"require_mfa":false}}}}"#,
login_id_json
)
}
#[test]
fn login_request_rejects_login_id_over_wire_max_len() {
let long_id = "L".repeat(256);
let err = deser_login_request(&login_body(&format!("\"{long_id}\"")))
.expect_err("超上限 login_id 应拒绝");
assert!(
err.to_string().contains("stp-login-id-too-long"),
"错误应含 too-long 码,实际: {err}"
);
assert!(!err.to_string().contains(&long_id), "错误不得回显输入内容");
}
#[test]
fn login_request_accepts_login_id_at_wire_max_len() {
let id = "L".repeat(255);
let req = deser_login_request(&login_body(&format!("\"{id}\"")))
.expect("255 字符 login_id 应通过");
assert_eq!(req.login_id.len(), 255);
}
#[test]
fn login_request_rejects_invalid_login_id_shapes() {
for (raw, code) in [
("\"\"", "stp-login-id-empty"),
("\" \"", "stp-login-id-empty"),
("\"\\u001fadmin\"", "stp-login-id-sep"),
("\"admin\\nroot\"", "stp-login-id-control-char"),
] {
let err =
deser_login_request(&login_body(raw)).expect_err(&format!("login_id={raw} 应拒绝"));
assert!(
err.to_string().contains(code),
"login_id={raw} 应含 {code},实际: {err}"
);
}
}
#[test]
fn renew_request_rejects_unknown_fields() {
let cases = [
r#"{"token":"t","params":{"remember_me":true}}"#,
r#"{"token":"t","remember_me":true}"#,
];
for body in cases {
let err: serde_json::Error = serde_json::from_str::<RenewToEquivalentRequest>(body)
.expect_err(&format!("未知字段应拒绝: {body}"));
assert!(
err.to_string().contains("unknown field"),
"应报 unknown field,实际: {err}"
);
}
let ok: RenewToEquivalentRequest =
serde_json::from_str(r#"{"token":"t"}"#).expect("仅 token 字段应通过");
assert_eq!(ok.token, "t");
}
}