use chrono::{DateTime, NaiveDate, NaiveTime, Utc};
use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};
use uuid::Uuid;
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct FieldDescriptor {
pub name: String,
pub field_type: DjangoFieldType,
pub nullable: bool,
pub has_default: bool,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum DjangoFieldType {
CharField { max_length: usize },
TextField,
IntegerField,
BigIntegerField,
FloatField,
DecimalField {
max_digits: u32,
decimal_places: u32,
},
BooleanField,
DateField,
TimeField,
DateTimeField,
UuidField,
JsonField,
BinaryField { max_length: Option<usize> },
EmailField { max_length: usize },
UrlField { max_length: usize },
SlugField { max_length: usize },
}
impl DjangoFieldType {
pub fn django_type_name(&self) -> &'static str {
match self {
DjangoFieldType::CharField { .. } => "CharField",
DjangoFieldType::TextField => "TextField",
DjangoFieldType::IntegerField => "IntegerField",
DjangoFieldType::BigIntegerField => "BigIntegerField",
DjangoFieldType::FloatField => "FloatField",
DjangoFieldType::DecimalField { .. } => "DecimalField",
DjangoFieldType::BooleanField => "BooleanField",
DjangoFieldType::DateField => "DateField",
DjangoFieldType::TimeField => "TimeField",
DjangoFieldType::DateTimeField => "DateTimeField",
DjangoFieldType::UuidField => "UUIDField",
DjangoFieldType::JsonField => "JSONField",
DjangoFieldType::BinaryField { .. } => "BinaryField",
DjangoFieldType::EmailField { .. } => "EmailField",
DjangoFieldType::UrlField { .. } => "URLField",
DjangoFieldType::SlugField { .. } => "SlugField",
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum FieldValue {
Text(String),
Integer(i32),
BigInteger(i64),
Float(f64),
Decimal(Decimal),
Boolean(bool),
Date(NaiveDate),
Time(NaiveTime),
DateTime(DateTime<Utc>),
Uuid(Uuid),
Json(serde_json::Value),
Binary(Vec<u8>),
Null,
}
impl FieldValue {
pub fn type_name(&self) -> &'static str {
match self {
FieldValue::Text(_) => "Text",
FieldValue::Integer(_) => "Integer",
FieldValue::BigInteger(_) => "BigInteger",
FieldValue::Float(_) => "Float",
FieldValue::Decimal(_) => "Decimal",
FieldValue::Boolean(_) => "Boolean",
FieldValue::Date(_) => "Date",
FieldValue::Time(_) => "Time",
FieldValue::DateTime(_) => "DateTime",
FieldValue::Uuid(_) => "UUID",
FieldValue::Json(_) => "JSON",
FieldValue::Binary(_) => "Binary",
FieldValue::Null => "Null",
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn field_descriptor_serializes_to_json() {
let field = FieldDescriptor {
name: "price".into(),
field_type: DjangoFieldType::DecimalField {
max_digits: 10,
decimal_places: 2,
},
nullable: false,
has_default: false,
};
let json = serde_json::to_string(&field).unwrap();
assert!(json.contains("price"));
assert!(json.contains("DecimalField"));
}
#[test]
fn field_value_type_names_are_descriptive() {
assert_eq!(FieldValue::Text("hello".into()).type_name(), "Text");
assert_eq!(FieldValue::Null.type_name(), "Null");
assert_eq!(FieldValue::Decimal(Decimal::new(100, 2)).type_name(), "Decimal");
assert_eq!(FieldValue::Uuid(Uuid::new_v4()).type_name(), "UUID");
}
#[test]
fn null_is_distinct_from_missing() {
let val = FieldValue::Null;
assert!(matches!(val, FieldValue::Null));
}
}