use super::field_config::{Audience, FieldConfig, FieldPermissions, RelationConfig, RelationType};
use super::table_config::{IndexConfig, TableConfig, TimestampFields};
#[cfg(feature = "mysql")]
use super::TableQuery;
use super::{FieldType, SortOrder, Validator};
use crate::error::BaseError;
use serde_json::{json, Map, Value};
use std::collections::{HashMap, HashSet};
use std::sync::Arc;
pub fn col(name: impl Into<String>) -> ColumnName {
ColumnName(name.into())
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
pub struct ColumnName(String);
impl ColumnName {
pub fn asc(self) -> Order {
Order {
field: self.0,
direction: SortOrder::Asc,
}
}
pub fn desc(self) -> Order {
Order {
field: self.0,
direction: SortOrder::Desc,
}
}
fn into_name(self) -> String {
self.0
}
}
impl From<&str> for ColumnName {
fn from(value: &str) -> Self {
Self(value.to_string())
}
}
impl From<String> for ColumnName {
fn from(value: String) -> Self {
Self(value)
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Order {
field: String,
direction: SortOrder,
}
#[derive(Debug, Clone)]
#[must_use = "字段定义必须传给 Table::fields"]
pub struct Field {
config: FieldConfig,
primary_key: bool,
unique: bool,
unique_name: Option<String>,
index: bool,
index_name: Option<String>,
created_at: bool,
updated_at: bool,
deleted_at: bool,
soft_delete: bool,
relation_display_fields: Option<Vec<String>>,
}
impl Field {
fn new(name: impl Into<String>, field_type: FieldType) -> Self {
Self {
config: FieldConfig::new(name, field_type),
primary_key: false,
unique: false,
unique_name: None,
index: false,
index_name: None,
created_at: false,
updated_at: false,
deleted_at: false,
soft_delete: false,
relation_display_fields: None,
}
}
pub fn id(name: impl Into<String>) -> Self {
Self::new(name, FieldType::BigInt)
.required()
.primary_key()
.auto_increment()
.not_writable()
}
pub fn string(name: impl Into<String>, max_length: usize) -> Self {
Self::new(name, FieldType::String { max_length })
}
pub fn integer(name: impl Into<String>) -> Self {
Self::new(name, FieldType::Integer)
}
pub fn bigint(name: impl Into<String>) -> Self {
Self::new(name, FieldType::BigInt)
}
pub fn float(name: impl Into<String>) -> Self {
Self::new(name, FieldType::Float)
}
pub fn double(name: impl Into<String>) -> Self {
Self::new(name, FieldType::Double)
}
pub fn decimal(name: impl Into<String>, precision: u8, scale: u8) -> Self {
Self::new(name, FieldType::Decimal { precision, scale })
}
pub fn boolean(name: impl Into<String>) -> Self {
Self::new(name, FieldType::Boolean)
}
pub fn date(name: impl Into<String>) -> Self {
Self::new(name, FieldType::Date)
}
pub fn datetime(name: impl Into<String>) -> Self {
Self::new(name, FieldType::DateTime)
}
pub fn timestamp(name: impl Into<String>) -> Self {
Self::new(name, FieldType::Timestamp)
}
pub fn json(name: impl Into<String>) -> Self {
Self::new(name, FieldType::Json)
}
pub fn text(name: impl Into<String>) -> Self {
Self::new(name, FieldType::Text)
}
pub fn enumeration<I, S>(name: impl Into<String>, values: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
Self::new(
name,
FieldType::Enum {
values: values.into_iter().map(Into::into).collect(),
},
)
}
pub fn created_at(name: impl Into<String>) -> Self {
let mut field = Self::bigint(name).required().not_writable();
field.created_at = true;
field
}
pub fn updated_at(name: impl Into<String>) -> Self {
let mut field = Self::bigint(name).required().not_writable();
field.updated_at = true;
field
}
pub fn soft_delete(name: impl Into<String>) -> Self {
let mut field = Self::bigint(name).not_writable();
field.deleted_at = true;
field.soft_delete = true;
field
}
pub fn label(mut self, label: impl Into<String>) -> Self {
self.config.display_name = label.into();
self
}
pub fn required(mut self) -> Self {
self.config.required = true;
self
}
pub fn nullable(mut self) -> Self {
self.config.required = false;
self
}
pub fn default(mut self, value: impl Into<Value>) -> Self {
self.config.default_value = Some(value.into());
self
}
pub fn auto_increment(mut self) -> Self {
self.config.auto_increment = true;
self
}
pub fn primary_key(mut self) -> Self {
self.primary_key = true;
self
}
pub fn unique(mut self) -> Self {
self.unique = true;
self
}
pub fn unique_named(mut self, name: impl Into<String>) -> Self {
self.unique = true;
self.unique_name = Some(name.into());
self
}
pub fn index(mut self) -> Self {
self.index = true;
self
}
pub fn index_named(mut self, name: impl Into<String>) -> Self {
self.index = true;
self.index_name = Some(name.into());
self
}
pub fn validator(mut self, validator: Validator) -> Self {
self.config.validators.push(validator);
self
}
pub fn min_length(self, value: usize) -> Self {
self.validator(Validator::MinLength(value))
}
pub fn max_length(self, value: usize) -> Self {
self.validator(Validator::MaxLength(value))
}
pub fn length(self, range: std::ops::RangeInclusive<usize>) -> Self {
self.min_length(*range.start()).max_length(*range.end())
}
pub fn min(self, value: f64) -> Self {
self.validator(Validator::Min(value))
}
pub fn max(self, value: f64) -> Self {
self.validator(Validator::Max(value))
}
pub fn email(self) -> Self {
self.validator(Validator::Email)
}
pub fn phone(self) -> Self {
self.validator(Validator::Phone)
}
pub fn url(self) -> Self {
self.validator(Validator::Url)
}
pub fn regex(self, pattern: impl Into<String>) -> Self {
self.validator(Validator::Regex(pattern.into()))
}
pub fn readable(mut self) -> Self {
self.config.permissions.readable = Audience::Everyone;
self
}
pub fn not_readable(mut self) -> Self {
self.config.permissions.readable = Audience::Nobody;
self
}
pub fn readable_by<I, S>(mut self, roles: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
self.config.permissions.readable = Audience::roles(roles);
self
}
pub fn writable_by<I, S>(mut self, roles: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
self.config.permissions.writable = Audience::roles(roles);
self
}
pub fn writable(mut self) -> Self {
self.config.permissions.writable = Audience::Everyone;
self
}
pub fn not_writable(mut self) -> Self {
self.config.permissions.writable = Audience::Nobody;
self
}
pub fn searchable(mut self) -> Self {
self.config.searchable = true;
self
}
pub fn filterable(mut self) -> Self {
self.config.filterable = true;
self.config.permissions.filterable = Audience::Everyone;
self
}
pub fn not_filterable(mut self) -> Self {
self.config.filterable = false;
self.config.permissions.filterable = Audience::Nobody;
self
}
pub fn filterable_by<I, S>(mut self, roles: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
self.config.filterable = true;
self.config.permissions.filterable = Audience::roles(roles);
self
}
pub fn sortable(mut self) -> Self {
self.config.sortable = true;
self.config.permissions.sortable = Audience::Everyone;
self
}
pub fn not_sortable(mut self) -> Self {
self.config.sortable = false;
self.config.permissions.sortable = Audience::Nobody;
self
}
pub fn sortable_by<I, S>(mut self, roles: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
self.config.sortable = true;
self.config.permissions.sortable = Audience::roles(roles);
self
}
pub fn tenant_key(mut self) -> Self {
self.config.tenant_key = true;
self
}
pub fn secret(mut self) -> Self {
self.config.hidden = true;
self.config.permissions = FieldPermissions {
readable: Audience::Nobody,
writable: Audience::Nobody,
filterable: Audience::Nobody,
sortable: Audience::Nobody,
};
self.config.searchable = false;
self.config.filterable = false;
self.config.sortable = false;
self
}
pub fn relation(
mut self,
table: impl Into<String>,
field: impl Into<String>,
relation_type: RelationType,
) -> Self {
self.config.relation = Some(RelationConfig {
table: table.into(),
field: field.into(),
display_fields: Vec::new(),
relation_type,
});
self
}
pub fn relation_display_fields<I, S>(mut self, fields: I) -> Self
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
self.relation_display_fields = Some(fields.into_iter().map(Into::into).collect());
self
}
}
#[derive(Debug, Clone)]
struct PendingIndex {
name: Option<String>,
fields: Vec<String>,
unique: bool,
}
#[derive(Debug, Clone)]
#[must_use = "表构建器必须调用 build"]
pub struct Table {
name: String,
label: Option<String>,
fields: Vec<Field>,
indexes: Vec<PendingIndex>,
default_order: Vec<Order>,
}
impl Table {
pub fn new(name: impl Into<String>) -> Self {
Self {
name: name.into(),
label: None,
fields: Vec::new(),
indexes: Vec::new(),
default_order: Vec::new(),
}
}
pub fn label(mut self, label: impl Into<String>) -> Self {
self.label = Some(label.into());
self
}
pub fn fields<I>(mut self, fields: I) -> Self
where
I: IntoIterator<Item = Field>,
{
self.fields.extend(fields);
self
}
pub fn unique<I, C>(mut self, fields: I) -> Self
where
I: IntoIterator<Item = C>,
C: Into<ColumnName>,
{
self.indexes.push(PendingIndex {
name: None,
fields: fields
.into_iter()
.map(|field| field.into().into_name())
.collect(),
unique: true,
});
self
}
pub fn unique_named<I, C>(mut self, name: impl Into<String>, fields: I) -> Self
where
I: IntoIterator<Item = C>,
C: Into<ColumnName>,
{
self.indexes.push(PendingIndex {
name: Some(name.into()),
fields: fields
.into_iter()
.map(|field| field.into().into_name())
.collect(),
unique: true,
});
self
}
pub fn index<I, C>(mut self, fields: I) -> Self
where
I: IntoIterator<Item = C>,
C: Into<ColumnName>,
{
self.indexes.push(PendingIndex {
name: None,
fields: fields
.into_iter()
.map(|field| field.into().into_name())
.collect(),
unique: false,
});
self
}
pub fn index_named<I, C>(mut self, name: impl Into<String>, fields: I) -> Self
where
I: IntoIterator<Item = C>,
C: Into<ColumnName>,
{
self.indexes.push(PendingIndex {
name: Some(name.into()),
fields: fields
.into_iter()
.map(|field| field.into().into_name())
.collect(),
unique: false,
});
self
}
pub fn default_order(mut self, order: Order) -> Self {
self.default_order = vec![order];
self
}
pub fn then_order(mut self, order: Order) -> Self {
self.default_order.push(order);
self
}
pub fn build(self) -> Result<TableDefinition, BaseError> {
validate_identifier("表", &self.name)?;
if self.fields.is_empty() {
return Err(BaseError::ConfigError(format!(
"表 {} 至少需要一个字段",
self.name
)));
}
let mut field_names = HashSet::with_capacity(self.fields.len());
let mut configs = HashMap::with_capacity(self.fields.len());
let mut primary_key: Option<String> = None;
let mut created_at: Option<String> = None;
let mut updated_at: Option<String> = None;
let mut deleted_at: Option<String> = None;
let mut soft_delete: Option<String> = None;
let mut tenant_key: Option<String> = None;
let mut indexes = self.indexes;
for mut field in self.fields {
validate_identifier("字段", &field.config.name)?;
if !field_names.insert(field.config.name.clone()) {
return Err(BaseError::ConfigError(format!(
"表 {} 存在重复字段: {}",
self.name, field.config.name
)));
}
if field.config.display_name.is_empty() {
field.config.display_name = field.config.name.clone();
}
if let Some(display_fields) = field.relation_display_fields.take() {
let relation = field.config.relation.as_mut().ok_or_else(|| {
BaseError::ConfigError(format!(
"表 {} 的字段 {} 未定义 relation,不能配置关联展示字段",
self.name, field.config.name
))
})?;
relation.display_fields = display_fields;
}
validate_field_shape(&self.name, &field)?;
if field.primary_key && primary_key.replace(field.config.name.clone()).is_some() {
return Err(BaseError::ConfigError(format!(
"表 {} 只能定义一个主键",
self.name
)));
}
if field.config.tenant_key && tenant_key.replace(field.config.name.clone()).is_some() {
return Err(BaseError::ConfigError(format!(
"表 {} 只能定义一个租户隔离字段",
self.name
)));
}
set_unique_role(
&self.name,
"created_at",
field.created_at,
&field.config.name,
&mut created_at,
)?;
set_unique_role(
&self.name,
"updated_at",
field.updated_at,
&field.config.name,
&mut updated_at,
)?;
set_unique_role(
&self.name,
"deleted_at",
field.deleted_at,
&field.config.name,
&mut deleted_at,
)?;
set_unique_role(
&self.name,
"soft_delete",
field.soft_delete,
&field.config.name,
&mut soft_delete,
)?;
if field.unique {
indexes.push(PendingIndex {
name: field.unique_name.take(),
fields: vec![field.config.name.clone()],
unique: true,
});
}
if field.index {
indexes.push(PendingIndex {
name: field.index_name.take(),
fields: vec![field.config.name.clone()],
unique: false,
});
}
configs.insert(field.config.name.clone(), field.config);
}
let primary_key = primary_key
.ok_or_else(|| BaseError::ConfigError(format!("表 {} 必须定义一个主键", self.name)))?;
let mut unique_indexes = Vec::new();
let mut normal_indexes = Vec::new();
let mut index_names = HashSet::new();
for index in indexes {
validate_index(&self.name, &field_names, &index, &mut index_names)?;
let config = IndexConfig::new(index.name, index.fields);
if index.unique {
unique_indexes.push(config);
} else {
normal_indexes.push(config);
}
}
let mut orders = Vec::with_capacity(self.default_order.len());
for order in self.default_order {
if !field_names.contains(&order.field) {
return Err(BaseError::ConfigError(format!(
"表 {} 的默认排序字段不存在: {}",
self.name, order.field
)));
}
orders.push((order.field, order.direction));
}
let timestamp_fields =
if created_at.is_some() || updated_at.is_some() || deleted_at.is_some() {
Some(TimestampFields::new(created_at, updated_at, deleted_at))
} else {
None
};
let table_ref = yang_db::TableRef::new(self.name.clone())
.map_err(|error| BaseError::ConfigError(error.to_string()))?;
let field_refs = field_names
.iter()
.map(|name| {
yang_db::FieldRef::new(name.clone())
.map(|field| (name.clone(), field))
.map_err(|error| BaseError::ConfigError(error.to_string()))
})
.collect::<Result<HashMap<_, _>, _>>()?;
Ok(TableDefinition {
config: Arc::new(TableConfig {
table_name: self.name.clone(),
table_ref,
display_name: self.label.unwrap_or(self.name),
primary_key,
fields: configs,
field_refs,
unique_indexes,
indexes: normal_indexes,
default_order: orders,
soft_delete_field: soft_delete,
timestamp_fields,
}),
})
}
}
#[derive(Debug, Clone)]
pub struct TableDefinition {
pub(crate) config: Arc<TableConfig>,
}
impl TableDefinition {
pub fn name(&self) -> &str {
&self.config.table_name
}
pub fn label(&self) -> &str {
&self.config.display_name
}
pub fn primary_key(&self) -> &str {
&self.config.primary_key
}
pub fn field_count(&self) -> usize {
self.config.fields.len()
}
pub fn field(&self, name: &str) -> Option<FieldMetadata<'_>> {
self.config
.fields
.get(name)
.map(|config| FieldMetadata { config })
}
pub fn fields(&self) -> Vec<FieldMetadata<'_>> {
let mut fields: Vec<_> = self
.config
.fields
.values()
.map(|config| FieldMetadata { config })
.collect();
fields.sort_by(|left, right| left.name().cmp(right.name()));
fields
}
pub fn soft_delete_field(&self) -> Option<&str> {
self.config.soft_delete_field.as_deref()
}
pub fn tenant_key_field(&self) -> Option<&str> {
self.config
.fields
.values()
.find(|field| field.tenant_key)
.map(|field| field.name.as_str())
}
pub fn input_schema(&self) -> Value {
self.json_schema(false, None)
}
pub fn output_schema(&self) -> Value {
self.json_schema(true, None)
}
pub fn input_schema_for_roles(&self, roles: &HashSet<String>) -> Value {
self.json_schema(false, Some(roles))
}
pub fn output_schema_for_roles(&self, roles: &HashSet<String>) -> Value {
self.json_schema(true, Some(roles))
}
#[cfg(feature = "mysql")]
pub(crate) fn field_schema(&self, name: &str) -> Option<Value> {
self.config.fields.get(name).map(field_json_schema)
}
fn json_schema(&self, output: bool, roles: Option<&HashSet<String>>) -> Value {
let mut properties = Map::new();
let mut required = Vec::new();
let mut names: Vec<_> = self.config.fields.keys().collect();
names.sort();
for name in names {
let field = &self.config.fields[name];
let generated = field.auto_increment
|| self
.config
.timestamp_fields
.as_ref()
.is_some_and(|timestamps| {
timestamps.created_at.as_deref() == Some(name.as_str())
|| timestamps.updated_at.as_deref() == Some(name.as_str())
|| timestamps.deleted_at.as_deref() == Some(name.as_str())
})
|| self.config.soft_delete_field.as_deref() == Some(name.as_str());
let audience = if output {
&field.permissions.readable
} else {
&field.permissions.writable
};
let audience_allows = roles.map_or_else(
|| !matches!(audience, Audience::Nobody),
|roles| audience.allows(roles),
);
if field.hidden || !audience_allows || (!output && generated) {
continue;
}
properties.insert(name.clone(), field_json_schema(field));
if field.required && (output || (!generated && field.default_value.is_none())) {
required.push(Value::String(name.clone()));
}
}
json!({
"type": "object",
"title": self.config.display_name,
"properties": properties,
"required": required,
"additionalProperties": false,
})
}
#[cfg(feature = "mysql")]
pub(crate) fn config(&self) -> &TableConfig {
&self.config
}
pub(crate) fn shared_config(&self) -> Arc<TableConfig> {
Arc::clone(&self.config)
}
pub fn validate_schema(
&self,
columns: &[super::SchemaColumn],
) -> super::SchemaValidationReport {
self.config.validate_schema(columns)
}
#[cfg(feature = "mysql")]
pub fn bind(&self, pool: Arc<sqlx::MySqlPool>) -> TableHandle {
TableHandle {
definition: self.clone(),
pool,
}
}
}
#[derive(Debug, Clone, Copy)]
pub struct FieldMetadata<'a> {
config: &'a FieldConfig,
}
impl<'a> FieldMetadata<'a> {
pub fn name(self) -> &'a str {
&self.config.name
}
pub fn label(self) -> &'a str {
&self.config.display_name
}
pub fn is_tenant_key(self) -> bool {
self.config.tenant_key
}
pub fn field_type(self) -> &'a FieldType {
&self.config.field_type
}
pub fn is_required(self) -> bool {
self.config.required
}
pub fn default_value(self) -> Option<&'a Value> {
self.config.default_value.as_ref()
}
pub fn is_auto_increment(self) -> bool {
self.config.auto_increment
}
pub fn is_searchable(self) -> bool {
self.config.searchable
}
pub fn is_filterable(self) -> bool {
self.config.filterable
}
pub fn is_sortable(self) -> bool {
self.config.sortable
}
pub fn is_secret(self) -> bool {
self.config.hidden
}
}
#[cfg(feature = "mysql")]
#[derive(Debug, Clone)]
pub struct TableHandle {
definition: TableDefinition,
pool: Arc<sqlx::MySqlPool>,
}
#[cfg(feature = "mysql")]
impl TableHandle {
pub fn definition(&self) -> &TableDefinition {
&self.definition
}
pub fn query<I, S>(&self, roles: I) -> TableQuery
where
I: IntoIterator<Item = S>,
S: Into<String>,
{
let roles: Arc<[String]> =
Arc::from(roles.into_iter().map(Into::into).collect::<Vec<String>>());
TableQuery::new(
self.definition.shared_config(),
roles,
Some(Arc::clone(&self.pool)),
)
}
}
fn validate_identifier(kind: &str, value: &str) -> Result<(), BaseError> {
let mut chars = value.chars();
let first = chars
.next()
.ok_or_else(|| BaseError::ConfigError(format!("{kind}名称不能为空")))?;
if value.len() > 64
|| !(first == '_' || first.is_ascii_alphabetic())
|| !chars.all(|character| character == '_' || character.is_ascii_alphanumeric())
{
return Err(BaseError::ConfigError(format!("非法{kind}名称: {value}")));
}
Ok(())
}
fn validate_field_shape(table: &str, field: &Field) -> Result<(), BaseError> {
match &field.config.field_type {
FieldType::String { max_length } if *max_length == 0 => {
return Err(BaseError::ConfigError(format!(
"表 {table} 的字符串字段 {} 长度必须大于 0",
field.config.name
)));
}
FieldType::Enum { values } => {
let unique: HashSet<_> = values.iter().collect();
if values.is_empty() || unique.len() != values.len() {
return Err(BaseError::ConfigError(format!(
"表 {table} 的枚举字段 {} 必须提供非空且不重复的候选值",
field.config.name
)));
}
}
FieldType::Decimal { precision, scale }
if *precision == 0 || *precision > 65 || *scale > *precision =>
{
return Err(BaseError::ConfigError(format!(
"表 {table} 的 DECIMAL 字段 {} 必须满足 1 <= precision <= 65 且 scale <= precision",
field.config.name
)));
}
_ => {}
}
if field.config.auto_increment
&& (!field.primary_key
|| !matches!(
field.config.field_type,
FieldType::Integer | FieldType::BigInt
))
{
return Err(BaseError::ConfigError(format!(
"表 {table} 的 auto_increment 仅允许用于整数主键字段: {}",
field.config.name
)));
}
if field.primary_key && !field.config.required {
return Err(BaseError::ConfigError(format!(
"表 {table} 的主键必须为必填字段: {}",
field.config.name
)));
}
if field.config.auto_increment && field.config.default_value.is_some() {
return Err(BaseError::ConfigError(format!(
"表 {table} 的自增字段不能配置默认值: {}",
field.config.name
)));
}
validate_validator_configuration(table, &field.config)?;
if let Some(default) = &field.config.default_value {
if matches!(field.config.field_type, FieldType::Text | FieldType::Json) {
return Err(BaseError::ConfigError(format!(
"表 {table} 的 TEXT/JSON 字段不能配置数据库默认值: {}",
field.config.name
)));
}
field.config.validate(default)?;
}
validate_audience(
table,
&field.config.name,
"读取",
&field.config.permissions.readable,
)?;
validate_audience(
table,
&field.config.name,
"写入",
&field.config.permissions.writable,
)?;
validate_audience(
table,
&field.config.name,
"筛选",
&field.config.permissions.filterable,
)?;
validate_audience(
table,
&field.config.name,
"排序",
&field.config.permissions.sortable,
)?;
if let Some(relation) = &field.config.relation {
validate_identifier("关联表", &relation.table)?;
validate_identifier("关联字段", &relation.field)?;
for display_field in &relation.display_fields {
validate_identifier("关联展示字段", display_field)?;
}
}
if (field.created_at || field.updated_at || field.deleted_at || field.soft_delete)
&& !matches!(
field.config.field_type,
FieldType::Integer | FieldType::BigInt | FieldType::Timestamp
)
{
return Err(BaseError::ConfigError(format!(
"表 {table} 的时间戳语义字段必须是整数或 Timestamp: {}",
field.config.name
)));
}
Ok(())
}
fn validate_validator_configuration(table: &str, field: &FieldConfig) -> Result<(), BaseError> {
let string_compatible = matches!(
field.field_type,
FieldType::String { .. }
| FieldType::Text
| FieldType::Enum { .. }
| FieldType::Date
| FieldType::DateTime
);
let numeric_compatible = matches!(
field.field_type,
FieldType::Integer
| FieldType::BigInt
| FieldType::Float
| FieldType::Double
| FieldType::Decimal { .. }
| FieldType::Timestamp
);
let mut min_length: Option<usize> = None;
let mut max_length: Option<usize> = None;
let mut minimum: Option<f64> = None;
let mut maximum: Option<f64> = None;
for validator in &field.validators {
match validator {
Validator::MinLength(value) => {
ensure_validator_type(table, field, validator, string_compatible)?;
min_length = Some(min_length.map_or(*value, |current| current.max(*value)));
}
Validator::MaxLength(value) => {
ensure_validator_type(table, field, validator, string_compatible)?;
max_length = Some(max_length.map_or(*value, |current| current.min(*value)));
}
Validator::Min(value) => {
ensure_validator_type(table, field, validator, numeric_compatible)?;
if !value.is_finite() {
return Err(BaseError::ConfigError(format!(
"表 {table} 的字段 {} 数值下限必须是有限数值",
field.name
)));
}
minimum = Some(minimum.map_or(*value, |current| current.max(*value)));
}
Validator::Max(value) => {
ensure_validator_type(table, field, validator, numeric_compatible)?;
if !value.is_finite() {
return Err(BaseError::ConfigError(format!(
"表 {table} 的字段 {} 数值上限必须是有限数值",
field.name
)));
}
maximum = Some(maximum.map_or(*value, |current| current.min(*value)));
}
Validator::Email
| Validator::EmailLoose
| Validator::Phone
| Validator::PhoneLoose
| Validator::Url => {
ensure_validator_type(table, field, validator, string_compatible)?;
}
Validator::Regex(pattern) => {
ensure_validator_type(table, field, validator, string_compatible)?;
#[cfg(feature = "validator")]
regex::Regex::new(pattern).map_err(|error| {
BaseError::ConfigError(format!(
"表 {table} 的字段 {} 正则表达式无效: {error}",
field.name
))
})?;
#[cfg(not(feature = "validator"))]
return Err(BaseError::ConfigError(format!(
"表 {table} 的字段 {} 使用正则验证器 {pattern:?} 时必须启用 validator feature",
field.name,
)));
}
Validator::Custom(_) => {}
}
}
if let (Some(min), Some(max)) = (min_length, max_length) {
if min > max {
return Err(BaseError::ConfigError(format!(
"表 {table} 的字段 {} 最小长度不能大于最大长度",
field.name
)));
}
}
if let (
FieldType::String {
max_length: storage_max,
},
Some(min),
) = (&field.field_type, min_length)
{
if min > *storage_max {
return Err(BaseError::ConfigError(format!(
"表 {table} 的字段 {} 最小长度不能超过字符串存储上限 {storage_max}",
field.name
)));
}
}
if let (Some(min), Some(max)) = (minimum, maximum) {
if min > max {
return Err(BaseError::ConfigError(format!(
"表 {table} 的字段 {} 数值下限不能大于上限",
field.name
)));
}
}
Ok(())
}
fn ensure_validator_type(
table: &str,
field: &FieldConfig,
validator: &Validator,
compatible: bool,
) -> Result<(), BaseError> {
if compatible {
return Ok(());
}
Err(BaseError::ConfigError(format!(
"表 {table} 的字段 {} 类型不能使用{}验证器",
field.name,
validator.display_name()
)))
}
fn validate_audience(
table: &str,
field: &str,
operation: &str,
audience: &Audience,
) -> Result<(), BaseError> {
if let Audience::Roles(roles) = audience {
if roles.is_empty() || roles.iter().any(|role| role.trim().is_empty()) {
return Err(BaseError::ConfigError(format!(
"表 {table} 的字段 {field} 的{operation}角色不能为空"
)));
}
}
Ok(())
}
fn set_unique_role(
table: &str,
role: &str,
enabled: bool,
field: &str,
target: &mut Option<String>,
) -> Result<(), BaseError> {
if !enabled {
return Ok(());
}
if let Some(existing) = target {
return Err(BaseError::ConfigError(format!(
"表 {table} 的 {role} 语义重复定义在 {existing} 和 {field}"
)));
}
*target = Some(field.to_string());
Ok(())
}
fn validate_index(
table: &str,
field_names: &HashSet<String>,
index: &PendingIndex,
index_names: &mut HashSet<String>,
) -> Result<(), BaseError> {
if index.fields.is_empty() {
return Err(BaseError::ConfigError(format!(
"表 {table} 的索引字段不能为空"
)));
}
let mut seen = HashSet::new();
for field in &index.fields {
if !field_names.contains(field) {
return Err(BaseError::ConfigError(format!(
"表 {table} 的索引字段不存在: {field}"
)));
}
if !seen.insert(field) {
return Err(BaseError::ConfigError(format!(
"表 {table} 的索引重复引用字段: {field}"
)));
}
}
let prefix = if index.unique { "uk" } else { "idx" };
let effective_name = index
.name
.clone()
.unwrap_or_else(|| format!("{prefix}_{table}_{}", index.fields.join("_")));
validate_identifier("索引", &effective_name)?;
if !index_names.insert(effective_name.clone()) {
return Err(BaseError::ConfigError(format!(
"表 {table} 存在重复索引名: {effective_name}"
)));
}
Ok(())
}
fn field_json_schema(field: &FieldConfig) -> Value {
let mut schema = Map::new();
let mut min_length: Option<usize> = None;
let mut max_length: Option<usize> = None;
let mut minimum: Option<f64> = None;
let mut maximum: Option<f64> = None;
let mut patterns = Vec::new();
let mut runtime_validators = Vec::new();
match &field.field_type {
FieldType::String {
max_length: storage_max,
} => {
schema.insert("type".into(), json!("string"));
max_length = Some(*storage_max);
}
FieldType::Text => {
schema.insert("type".into(), json!("string"));
}
FieldType::Integer | FieldType::BigInt | FieldType::Timestamp => {
schema.insert("type".into(), json!("integer"));
}
FieldType::Float | FieldType::Double => {
schema.insert("type".into(), json!("number"));
}
FieldType::Decimal { precision, scale } => {
schema.insert("type".into(), json!("string"));
schema.insert("format".into(), json!("decimal"));
schema.insert("x-precision".into(), json!(precision));
schema.insert("x-scale".into(), json!(scale));
}
FieldType::Boolean => {
schema.insert("type".into(), json!("boolean"));
}
FieldType::Date => {
schema.insert("type".into(), json!("string"));
schema.insert("format".into(), json!("date"));
}
FieldType::DateTime => {
schema.insert("type".into(), json!("string"));
schema.insert("format".into(), json!("date-time"));
}
FieldType::Json => {
schema.insert("type".into(), json!(["object", "array"]));
}
FieldType::Enum { values } => {
schema.insert("type".into(), json!("string"));
schema.insert("enum".into(), json!(values));
}
}
for validator in &field.validators {
match validator {
Validator::MinLength(value) => {
min_length = Some(min_length.map_or(*value, |current| current.max(*value)));
}
Validator::MaxLength(value) => {
max_length = Some(max_length.map_or(*value, |current| current.min(*value)));
}
Validator::Min(value) => {
minimum = Some(minimum.map_or(*value, |current| current.max(*value)));
}
Validator::Max(value) => {
maximum = Some(maximum.map_or(*value, |current| current.min(*value)));
}
Validator::Email => {
#[cfg(feature = "validator")]
patterns.push(r"^[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}$".to_string());
#[cfg(not(feature = "validator"))]
patterns.push("@".to_string());
}
Validator::EmailLoose => patterns.push("@".to_string()),
Validator::Phone => {
#[cfg(feature = "validator")]
patterns.push(r"^\+?[1-9]\d{1,14}$".to_string());
#[cfg(not(feature = "validator"))]
patterns.push(r"^[0-9+\-]*$".to_string());
}
Validator::PhoneLoose => patterns.push(r"^[0-9\-]*$".to_string()),
Validator::Url => patterns.push(r"^https?://".to_string()),
Validator::Regex(pattern) => patterns.push(pattern.clone()),
Validator::Custom(_) => runtime_validators.push("custom"),
}
}
if let Some(value) = min_length {
schema.insert("minLength".into(), json!(value));
}
if let Some(value) = max_length {
schema.insert("maxLength".into(), json!(value));
}
if let Some(value) = minimum {
schema.insert("minimum".into(), json!(value));
}
if let Some(value) = maximum {
schema.insert("maximum".into(), json!(value));
}
match patterns.as_slice() {
[] => {}
[pattern] => {
schema.insert("pattern".into(), json!(pattern));
}
patterns => {
schema.insert(
"allOf".into(),
Value::Array(
patterns
.iter()
.map(|pattern| json!({ "pattern": pattern }))
.collect(),
),
);
}
}
if !runtime_validators.is_empty() {
schema.insert(
"x-yang-runtime-validators".into(),
json!(runtime_validators),
);
}
if let Some(relation) = &field.relation {
let relation_type = match relation.relation_type {
RelationType::OneToOne => "one_to_one",
RelationType::OneToMany => "one_to_many",
RelationType::ManyToOne => "many_to_one",
RelationType::ManyToMany => "many_to_many",
};
schema.insert(
"x-yang-relation".into(),
json!({
"table": relation.table,
"field": relation.field,
"displayFields": relation.display_fields,
"type": relation_type,
}),
);
}
if !field.required {
if let Some(field_types) = schema.get_mut("type") {
match field_types {
Value::String(field_type) => {
*field_types = json!([field_type.clone(), "null"]);
}
Value::Array(types) if !types.iter().any(|value| value == "null") => {
types.push(json!("null"));
}
_ => {}
}
}
if let Some(Value::Array(values)) = schema.get_mut("enum") {
values.push(Value::Null);
}
}
if !field.display_name.is_empty() {
schema.insert("title".into(), json!(field.display_name));
}
if let Some(default) = &field.default_value {
schema.insert("default".into(), default.clone());
}
Value::Object(schema)
}