use crate::error::BaseError;
use serde::{Deserialize, Serialize};
fn value_type_name(value: &serde_json::Value) -> &'static str {
match value {
serde_json::Value::Null => "null",
serde_json::Value::Bool(_) => "boolean",
serde_json::Value::Number(_) => "number",
serde_json::Value::String(_) => "string",
serde_json::Value::Array(_) => "array",
serde_json::Value::Object(_) => "object",
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[non_exhaustive]
pub enum FieldType {
String {
max_length: usize,
},
Integer,
BigInt,
Float,
Double,
Boolean,
Date,
DateTime,
Timestamp,
Json,
Text,
Enum {
values: Vec<String>,
},
ForeignKey {
table: String,
field: String,
},
}
impl FieldType {
pub fn display_name(&self) -> &str {
match self {
FieldType::String { .. } => "字符串",
FieldType::Integer => "整数",
FieldType::BigInt => "长整数",
FieldType::Float => "单精度浮点数",
FieldType::Double => "双精度浮点数",
FieldType::Boolean => "布尔值",
FieldType::Date => "日期",
FieldType::DateTime => "日期时间",
FieldType::Timestamp => "时间戳",
FieldType::Json => "JSON",
FieldType::Text => "文本",
FieldType::Enum { .. } => "枚举",
FieldType::ForeignKey { .. } => "外键",
}
}
pub fn is_numeric(&self) -> bool {
matches!(
self,
FieldType::Integer | FieldType::BigInt | FieldType::Float | FieldType::Double
)
}
pub fn is_temporal(&self) -> bool {
matches!(
self,
FieldType::Date | FieldType::DateTime | FieldType::Timestamp
)
}
pub fn is_text(&self) -> bool {
matches!(self, FieldType::String { .. } | FieldType::Text)
}
pub fn validate(&self, field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
match self {
FieldType::String { max_length } => {
if let Some(s) = value.as_str() {
let len = s.chars().count();
if len > *max_length {
return Err(BaseError::StringTooLong(
field_name.to_string(),
len,
*max_length,
));
}
Ok(())
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望字符串类型,实际类型: {}", value_type_name(value)),
))
}
}
FieldType::Integer => {
if value.is_i64() || value.is_u64() {
if let Some(n) = value.as_i64() {
if n >= i32::MIN as i64 && n <= i32::MAX as i64 {
return Ok(());
}
}
Err(BaseError::InvalidFieldType(
field_name.to_string(),
"整数值超出 i32 范围".to_string(),
))
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望整数类型,实际类型: {}", value_type_name(value)),
))
}
}
FieldType::BigInt => {
if value.is_i64() || value.is_u64() {
Ok(())
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望长整数类型,实际类型: {}", value_type_name(value)),
))
}
}
FieldType::Float => {
if value.is_f64() || value.is_i64() || value.is_u64() {
if let Some(n) = value.as_f64() {
if n.is_finite() && n.abs() <= f32::MAX as f64 {
return Ok(());
}
}
Err(BaseError::InvalidFieldType(
field_name.to_string(),
"浮点数值超出 f32 范围".to_string(),
))
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望浮点数类型,实际类型: {}", value_type_name(value)),
))
}
}
FieldType::Double => {
if value.is_f64() || value.is_i64() || value.is_u64() {
Ok(())
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望双精度浮点数类型,实际类型: {}", value_type_name(value)),
))
}
}
FieldType::Boolean => {
if value.is_boolean() {
Ok(())
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望布尔类型,实际类型: {}", value_type_name(value)),
))
}
}
FieldType::Date => validate_date(field_name, value),
FieldType::DateTime => validate_datetime(field_name, value),
FieldType::Timestamp => validate_timestamp(field_name, value),
FieldType::Enum { values } => {
if let Some(s) = value.as_str() {
if values.contains(&s.to_string()) {
Ok(())
} else {
Err(BaseError::InvalidEnumValue(
field_name.to_string(),
s.to_string(),
))
}
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!(
"期望字符串类型的枚举值,实际类型: {}",
value_type_name(value)
),
))
}
}
FieldType::Json => {
if let Some(s) = value.as_str() {
serde_json::from_str::<serde_json::Value>(s)
.map(|_| ())
.map_err(|e| {
BaseError::InvalidJsonFormat(field_name.to_string(), e.to_string())
})
} else {
if value.is_object() || value.is_array() {
Ok(())
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望 JSON 对象或数组,实际类型: {}", value_type_name(value)),
))
}
}
}
FieldType::Text => {
if value.as_str().is_some() {
Ok(())
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望文本字符串类型,实际类型: {}", value_type_name(value)),
))
}
}
FieldType::ForeignKey { .. } => Ok(()),
}
}
}
fn validate_date(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
if let Some(s) = value.as_str() {
chrono::NaiveDate::parse_from_str(s, "%Y-%m-%d")
.map(|_| ())
.map_err(|_| {
BaseError::InvalidFieldType(
field_name.to_string(),
format!("日期格式无效,期望 YYYY-MM-DD,实际: {}", s),
)
})
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望日期字符串类型,实际类型: {}", value_type_name(value)),
))
}
}
fn validate_datetime(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
if let Some(s) = value.as_str() {
if chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%dT%H:%M:%S").is_ok()
|| chrono::NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S").is_ok()
{
Ok(())
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!(
"日期时间格式无效,期望 YYYY-MM-DDTHH:MM:SS 或 YYYY-MM-DD HH:MM:SS,实际: {}",
s
),
))
}
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!(
"期望日期时间字符串类型,实际类型: {}",
value_type_name(value)
),
))
}
}
fn validate_timestamp(field_name: &str, value: &serde_json::Value) -> Result<(), BaseError> {
if let Some(ts) = value.as_i64() {
chrono::DateTime::<chrono::Utc>::from_timestamp_secs(ts)
.map(|_| ())
.ok_or_else(|| {
BaseError::InvalidFieldType(
field_name.to_string(),
format!("时间戳超出有效范围,实际: {}", ts),
)
})
} else {
Err(BaseError::InvalidFieldType(
field_name.to_string(),
format!("期望 Unix 时间戳整数,实际类型: {}", value_type_name(value)),
))
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_field_type_display_name() {
assert_eq!(
FieldType::String { max_length: 50 }.display_name(),
"字符串"
);
assert_eq!(FieldType::Integer.display_name(), "整数");
assert_eq!(FieldType::BigInt.display_name(), "长整数");
assert_eq!(FieldType::Float.display_name(), "单精度浮点数");
assert_eq!(FieldType::Double.display_name(), "双精度浮点数");
assert_eq!(FieldType::Boolean.display_name(), "布尔值");
assert_eq!(FieldType::Date.display_name(), "日期");
assert_eq!(FieldType::DateTime.display_name(), "日期时间");
assert_eq!(FieldType::Timestamp.display_name(), "时间戳");
assert_eq!(FieldType::Json.display_name(), "JSON");
assert_eq!(FieldType::Text.display_name(), "文本");
assert_eq!(
FieldType::Enum {
values: vec!["a".to_string()]
}
.display_name(),
"枚举"
);
assert_eq!(
FieldType::ForeignKey {
table: "users".to_string(),
field: "id".to_string()
}
.display_name(),
"外键"
);
}
#[test]
fn test_is_numeric() {
assert!(FieldType::Integer.is_numeric());
assert!(FieldType::BigInt.is_numeric());
assert!(FieldType::Float.is_numeric());
assert!(FieldType::Double.is_numeric());
assert!(!FieldType::String { max_length: 50 }.is_numeric());
assert!(!FieldType::Boolean.is_numeric());
}
#[test]
fn test_is_temporal() {
assert!(FieldType::Date.is_temporal());
assert!(FieldType::DateTime.is_temporal());
assert!(FieldType::Timestamp.is_temporal());
assert!(!FieldType::String { max_length: 50 }.is_temporal());
assert!(!FieldType::Integer.is_temporal());
}
#[test]
fn test_is_text() {
assert!(FieldType::String { max_length: 50 }.is_text());
assert!(FieldType::Text.is_text());
assert!(!FieldType::Integer.is_text());
assert!(!FieldType::Boolean.is_text());
}
#[test]
fn test_field_type_equality() {
let type1 = FieldType::String { max_length: 50 };
let type2 = FieldType::String { max_length: 50 };
let type3 = FieldType::String { max_length: 100 };
assert_eq!(type1, type2);
assert_ne!(type1, type3);
}
#[test]
fn test_enum_type() {
let enum_type = FieldType::Enum {
values: vec![
"pending".to_string(),
"approved".to_string(),
"rejected".to_string(),
],
};
assert_eq!(enum_type.display_name(), "枚举");
assert!(!enum_type.is_numeric());
assert!(!enum_type.is_temporal());
assert!(!enum_type.is_text());
}
#[test]
fn test_foreign_key_type() {
let fk_type = FieldType::ForeignKey {
table: "users".to_string(),
field: "id".to_string(),
};
assert_eq!(fk_type.display_name(), "外键");
assert!(!fk_type.is_numeric());
assert!(!fk_type.is_temporal());
assert!(!fk_type.is_text());
}
#[test]
fn test_validate_string_success() {
let field_type = FieldType::String { max_length: 10 };
assert!(field_type
.validate("name", &serde_json::json!("hello"))
.is_ok());
assert!(field_type.validate("name", &serde_json::json!("")).is_ok());
assert!(field_type
.validate("name", &serde_json::json!("1234567890"))
.is_ok());
}
#[test]
fn test_validate_string_too_long() {
let field_type = FieldType::String { max_length: 10 };
let result = field_type.validate("name", &serde_json::json!("this is too long"));
assert!(result.is_err());
assert!(
matches!(result, Err(BaseError::StringTooLong(ref field, 16, 10)) if field == "name"),
"期望 StringTooLong 错误,实际: {:?}",
result
);
}
#[test]
fn test_validate_string_invalid_type() {
let field_type = FieldType::String { max_length: 10 };
assert!(field_type
.validate("name", &serde_json::json!(123))
.is_err());
assert!(field_type
.validate("name", &serde_json::json!(true))
.is_err());
assert!(field_type
.validate("name", &serde_json::json!(null))
.is_err());
}
#[test]
fn test_validate_integer_success() {
let field_type = FieldType::Integer;
assert!(field_type.validate("age", &serde_json::json!(25)).is_ok());
assert!(field_type.validate("age", &serde_json::json!(0)).is_ok());
assert!(field_type.validate("age", &serde_json::json!(-100)).is_ok());
assert!(field_type
.validate("age", &serde_json::json!(i32::MAX))
.is_ok());
assert!(field_type
.validate("age", &serde_json::json!(i32::MIN))
.is_ok());
}
#[test]
fn test_validate_integer_out_of_range() {
let field_type = FieldType::Integer;
let result = field_type.validate("age", &serde_json::json!(i64::MAX));
assert!(result.is_err());
}
#[test]
fn test_validate_integer_invalid_type() {
let field_type = FieldType::Integer;
assert!(field_type
.validate("age", &serde_json::json!("not a number"))
.is_err());
assert!(field_type
.validate("age", &serde_json::json!(true))
.is_err());
assert!(field_type.validate("age", &serde_json::json!(3.5)).is_err());
}
#[test]
fn test_validate_bigint_success() {
let field_type = FieldType::BigInt;
assert!(field_type
.validate("id", &serde_json::json!(123456789))
.is_ok());
assert!(field_type
.validate("id", &serde_json::json!(i64::MAX))
.is_ok());
assert!(field_type
.validate("id", &serde_json::json!(i64::MIN))
.is_ok());
}
#[test]
fn test_validate_bigint_invalid_type() {
let field_type = FieldType::BigInt;
assert!(field_type
.validate("id", &serde_json::json!("not a number"))
.is_err());
assert!(field_type.validate("id", &serde_json::json!(3.5)).is_err());
}
#[test]
fn test_validate_float_success() {
let field_type = FieldType::Float;
assert!(field_type
.validate("price", &serde_json::json!(3.5))
.is_ok());
assert!(field_type
.validate("price", &serde_json::json!(0.0))
.is_ok());
assert!(field_type
.validate("price", &serde_json::json!(-1.5))
.is_ok());
assert!(field_type
.validate("price", &serde_json::json!(100))
.is_ok());
}
#[test]
fn test_validate_float_invalid_type() {
let field_type = FieldType::Float;
assert!(field_type
.validate("price", &serde_json::json!("not a number"))
.is_err());
assert!(field_type
.validate("price", &serde_json::json!(true))
.is_err());
}
#[test]
fn test_validate_double_success() {
let field_type = FieldType::Double;
assert!(field_type
.validate("amount", &serde_json::json!(123.456))
.is_ok());
assert!(field_type
.validate("amount", &serde_json::json!(0.0))
.is_ok());
assert!(field_type
.validate("amount", &serde_json::json!(100))
.is_ok());
}
#[test]
fn test_validate_double_invalid_type() {
let field_type = FieldType::Double;
assert!(field_type
.validate("amount", &serde_json::json!("not a number"))
.is_err());
assert!(field_type
.validate("amount", &serde_json::json!(true))
.is_err());
}
#[test]
fn test_validate_boolean_success() {
let field_type = FieldType::Boolean;
assert!(field_type
.validate("active", &serde_json::json!(true))
.is_ok());
assert!(field_type
.validate("active", &serde_json::json!(false))
.is_ok());
}
#[test]
fn test_validate_boolean_invalid_type() {
let field_type = FieldType::Boolean;
assert!(field_type
.validate("active", &serde_json::json!("true"))
.is_err());
assert!(field_type
.validate("active", &serde_json::json!(1))
.is_err());
assert!(field_type
.validate("active", &serde_json::json!(0))
.is_err());
}
#[test]
fn test_validate_date_success() {
let field_type = FieldType::Date;
assert!(field_type
.validate("birthday", &serde_json::json!("2026-05-27"))
.is_ok());
}
#[test]
fn test_validate_date_invalid_format() {
let field_type = FieldType::Date;
let result = field_type.validate("birthday", &serde_json::json!("2026/05/27"));
assert!(result.is_err());
assert!(
matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "birthday")
);
}
#[test]
fn test_validate_date_invalid_type() {
let field_type = FieldType::Date;
let result = field_type.validate("birthday", &serde_json::json!(20260527));
assert!(result.is_err());
assert!(
matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "birthday")
);
}
#[test]
fn test_validate_datetime_success() {
let field_type = FieldType::DateTime;
assert!(field_type
.validate("created_at", &serde_json::json!("2026-05-27 13:45:30"))
.is_ok());
}
#[test]
fn test_validate_datetime_invalid_format() {
let field_type = FieldType::DateTime;
assert!(field_type
.validate("created_at", &serde_json::json!("2026-05-27T13:45:30"))
.is_ok());
let result = field_type.validate("created_at", &serde_json::json!("2026/05/27 13:45:30"));
assert!(result.is_err());
assert!(
matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "created_at")
);
}
#[test]
fn test_validate_datetime_roundtrip_from_dynamic_row() {
let field_type = FieldType::DateTime;
let read_back = serde_json::json!("2026-05-27T13:45:30");
assert!(field_type.validate("created_at", &read_back).is_ok());
}
#[test]
fn test_validate_timestamp_success() {
let field_type = FieldType::Timestamp;
assert!(field_type
.validate("created_at", &serde_json::json!(1_764_221_130_i64))
.is_ok());
}
#[test]
fn test_validate_timestamp_invalid_type() {
let field_type = FieldType::Timestamp;
let result = field_type.validate("created_at", &serde_json::json!("2026-05-27 13:45:30"));
assert!(result.is_err());
assert!(
matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "created_at")
);
}
#[test]
fn test_validate_text_success() {
let field_type = FieldType::Text;
assert!(field_type
.validate("content", &serde_json::json!("hello"))
.is_ok());
assert!(field_type
.validate("content", &serde_json::json!("a".repeat(100_000)))
.is_ok());
assert!(field_type
.validate("content", &serde_json::json!(""))
.is_ok());
}
#[test]
fn test_validate_text_invalid_type() {
let field_type = FieldType::Text;
let result = field_type.validate("content", &serde_json::json!(123));
assert!(
matches!(result, Err(BaseError::InvalidFieldType(ref field, _)) if field == "content")
);
assert!(field_type
.validate("content", &serde_json::json!(true))
.is_err());
assert!(field_type
.validate("content", &serde_json::json!(null))
.is_err());
}
#[test]
fn test_validate_foreign_key_not_enforced() {
let field_type = FieldType::ForeignKey {
table: "users".to_string(),
field: "id".to_string(),
};
assert!(field_type
.validate("user_id", &serde_json::json!(1))
.is_ok());
assert!(field_type
.validate("user_id", &serde_json::json!("uuid-string"))
.is_ok());
assert!(field_type
.validate("user_id", &serde_json::json!(null))
.is_ok());
}
#[test]
fn test_validate_enum_success() {
let field_type = FieldType::Enum {
values: vec![
"pending".to_string(),
"approved".to_string(),
"rejected".to_string(),
],
};
assert!(field_type
.validate("status", &serde_json::json!("pending"))
.is_ok());
assert!(field_type
.validate("status", &serde_json::json!("approved"))
.is_ok());
assert!(field_type
.validate("status", &serde_json::json!("rejected"))
.is_ok());
}
#[test]
fn test_validate_enum_invalid_value() {
let field_type = FieldType::Enum {
values: vec![
"pending".to_string(),
"approved".to_string(),
"rejected".to_string(),
],
};
let result = field_type.validate("status", &serde_json::json!("invalid"));
assert!(result.is_err());
assert!(
matches!(result, Err(BaseError::InvalidEnumValue(ref field, ref value)) if field == "status" && value == "invalid"),
"期望 InvalidEnumValue 错误,实际: {:?}",
result
);
}
#[test]
fn test_validate_enum_invalid_type() {
let field_type = FieldType::Enum {
values: vec!["pending".to_string()],
};
assert!(field_type
.validate("status", &serde_json::json!(123))
.is_err());
assert!(field_type
.validate("status", &serde_json::json!(true))
.is_err());
}
#[test]
fn test_validate_json_success() {
let field_type = FieldType::Json;
assert!(field_type
.validate("data", &serde_json::json!({"key": "value"}))
.is_ok());
assert!(field_type
.validate("data", &serde_json::json!([1, 2, 3]))
.is_ok());
assert!(field_type
.validate("data", &serde_json::json!("{\"key\": \"value\"}"))
.is_ok());
assert!(field_type
.validate("data", &serde_json::json!("[1, 2, 3]"))
.is_ok());
}
#[test]
fn test_validate_json_invalid_format() {
let field_type = FieldType::Json;
let result = field_type.validate("data", &serde_json::json!("not a json"));
assert!(result.is_err());
assert!(
matches!(result, Err(BaseError::InvalidJsonFormat(ref field, _)) if field == "data"),
"期望 InvalidJsonFormat 错误,实际: {:?}",
result
);
}
#[test]
fn test_validate_json_invalid_type() {
let field_type = FieldType::Json;
assert!(field_type
.validate("data", &serde_json::json!(123))
.is_err());
assert!(field_type
.validate("data", &serde_json::json!(true))
.is_err());
assert!(field_type
.validate("data", &serde_json::json!(null))
.is_err());
}
}