324 lines
11 KiB
Rust
324 lines
11 KiB
Rust
use crate::database::schema::Schema;
|
|
use serde::{Deserialize, Serialize};
|
|
use serde_json::Value;
|
|
use std::collections::BTreeMap;
|
|
use std::sync::Arc;
|
|
use std::sync::OnceLock;
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct Case {
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub when: Option<Arc<Schema>>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub then: Option<Arc<Schema>>,
|
|
#[serde(rename = "else")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub else_: Option<Arc<Schema>>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, Default)]
|
|
pub struct SchemaObject {
|
|
// Core Schema Keywords
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub description: Option<String>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub title: Option<String>,
|
|
#[serde(default)] // Allow missing type
|
|
#[serde(rename = "type")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub type_: Option<SchemaTypeOrArray>, // Handles string or array of strings
|
|
|
|
// Object Keywords
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub properties: Option<BTreeMap<String, Arc<Schema>>>,
|
|
#[serde(rename = "patternProperties")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub pattern_properties: Option<BTreeMap<String, Arc<Schema>>>,
|
|
#[serde(rename = "additionalProperties")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub additional_properties: Option<Arc<Schema>>,
|
|
#[serde(rename = "family")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub family: Option<String>,
|
|
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub required: Option<Vec<String>>,
|
|
|
|
// dependencies can be schema dependencies or property dependencies
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub dependencies: Option<BTreeMap<String, Dependency>>,
|
|
|
|
// Array Keywords
|
|
#[serde(rename = "items")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub items: Option<Arc<Schema>>,
|
|
#[serde(rename = "prefixItems")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub prefix_items: Option<Vec<Arc<Schema>>>,
|
|
|
|
// String Validation
|
|
#[serde(rename = "minLength")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub min_length: Option<f64>,
|
|
#[serde(rename = "maxLength")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub max_length: Option<f64>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub pattern: Option<String>,
|
|
|
|
// Array Validation
|
|
#[serde(rename = "minItems")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub min_items: Option<f64>,
|
|
#[serde(rename = "maxItems")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub max_items: Option<f64>,
|
|
#[serde(rename = "uniqueItems")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub unique_items: Option<bool>,
|
|
#[serde(rename = "contains")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub contains: Option<Arc<Schema>>,
|
|
#[serde(rename = "minContains")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub min_contains: Option<f64>,
|
|
#[serde(rename = "maxContains")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub max_contains: Option<f64>,
|
|
|
|
// Object Validation
|
|
#[serde(rename = "minProperties")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub min_properties: Option<f64>,
|
|
#[serde(rename = "maxProperties")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub max_properties: Option<f64>,
|
|
#[serde(rename = "propertyNames")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub property_names: Option<Arc<Schema>>,
|
|
|
|
// Numeric Validation
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub format: Option<String>,
|
|
#[serde(rename = "enum")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub enum_: Option<Vec<Value>>, // `enum` is a reserved keyword in Rust
|
|
#[serde(
|
|
default,
|
|
rename = "const",
|
|
deserialize_with = "crate::database::object::deserialize_some"
|
|
)]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub const_: Option<Value>,
|
|
|
|
// Numeric Validation
|
|
#[serde(rename = "multipleOf")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub multiple_of: Option<f64>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub minimum: Option<f64>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub maximum: Option<f64>,
|
|
#[serde(rename = "exclusiveMinimum")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub exclusive_minimum: Option<f64>,
|
|
#[serde(rename = "exclusiveMaximum")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub exclusive_maximum: Option<f64>,
|
|
|
|
// Combining Keywords
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub cases: Option<Vec<Case>>,
|
|
#[serde(rename = "oneOf")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub one_of: Option<Vec<Arc<Schema>>>,
|
|
#[serde(rename = "not")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub not: Option<Arc<Schema>>,
|
|
|
|
// Custom Vocabularies
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub form: Option<Vec<String>>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub display: Option<Vec<String>>,
|
|
#[serde(rename = "enumNames")]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub enum_names: Option<Vec<String>>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub control: Option<String>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub actions: Option<BTreeMap<String, Action>>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub computer: Option<String>,
|
|
#[serde(default)]
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub extensible: Option<bool>,
|
|
|
|
// Contains ALL structural fields perfectly flattened from the ENTIRE Database inheritance tree (e.g. `entity` fields like `id`) as well as local fields hidden inside conditional `cases` blocks.
|
|
// This JSON exported array gives clients absolute deterministic visibility to O(1) validation and masking bounds without duplicating structural memory.
|
|
#[serde(rename = "compiledPropertyNames")]
|
|
#[serde(skip_deserializing)]
|
|
#[serde(skip_serializing_if = "crate::database::object::is_once_lock_vec_empty")]
|
|
#[serde(serialize_with = "crate::database::object::serialize_once_lock")]
|
|
pub compiled_property_names: OnceLock<Vec<String>>,
|
|
|
|
// Internal structural representation caching active AST Node maps. Unlike the Go framework counterpart, the JSPG implementation DOES natively include ALL ancestral inheritance boundary schemas because it compiles locally against the raw database graph.
|
|
#[serde(skip)]
|
|
pub compiled_properties: OnceLock<BTreeMap<String, Arc<Schema>>>,
|
|
|
|
#[serde(rename = "compiledDiscriminator")]
|
|
#[serde(skip_deserializing)]
|
|
#[serde(skip_serializing_if = "crate::database::object::is_once_lock_string_empty")]
|
|
#[serde(serialize_with = "crate::database::object::serialize_once_lock")]
|
|
pub compiled_discriminator: OnceLock<String>,
|
|
|
|
#[serde(rename = "compiledOptions")]
|
|
#[serde(skip_deserializing)]
|
|
#[serde(skip_serializing_if = "crate::database::object::is_once_lock_map_empty")]
|
|
#[serde(serialize_with = "crate::database::object::serialize_once_lock")]
|
|
pub compiled_options: OnceLock<BTreeMap<String, (Option<usize>, Option<String>)>>,
|
|
|
|
#[serde(rename = "compiledEdges")]
|
|
#[serde(skip_deserializing)]
|
|
#[serde(skip_serializing_if = "crate::database::object::is_once_lock_map_empty")]
|
|
#[serde(serialize_with = "crate::database::object::serialize_once_lock")]
|
|
pub compiled_edges: OnceLock<BTreeMap<String, crate::database::edge::Edge>>,
|
|
|
|
#[serde(skip)]
|
|
pub compiled_format: OnceLock<CompiledFormat>,
|
|
#[serde(skip)]
|
|
pub compiled_pattern: OnceLock<CompiledRegex>,
|
|
#[serde(skip)]
|
|
pub compiled_pattern_properties: OnceLock<Vec<(CompiledRegex, Arc<Schema>)>>,
|
|
}
|
|
|
|
/// Represents a compiled format validator
|
|
#[derive(Clone)]
|
|
pub enum CompiledFormat {
|
|
Func(fn(&serde_json::Value) -> Result<(), Box<dyn std::error::Error + Send + Sync>>),
|
|
Regex(regex::Regex),
|
|
}
|
|
|
|
impl std::fmt::Debug for CompiledFormat {
|
|
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
|
|
match self {
|
|
CompiledFormat::Func(_) => write!(f, "CompiledFormat::Func(...)"),
|
|
CompiledFormat::Regex(r) => write!(f, "CompiledFormat::Regex({:?})", r),
|
|
}
|
|
}
|
|
}
|
|
|
|
/// A wrapper for compiled regex patterns
|
|
#[derive(Debug, Clone)]
|
|
pub struct CompiledRegex(pub regex::Regex);
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
#[serde(untagged)]
|
|
pub enum SchemaTypeOrArray {
|
|
Single(String),
|
|
Multiple(Vec<String>),
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct Action {
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub navigate: Option<String>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub punc: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
#[serde(untagged)]
|
|
pub enum Dependency {
|
|
Props(Vec<String>),
|
|
Schema(Arc<Schema>),
|
|
}
|
|
|
|
pub fn serialize_once_lock<T: serde::Serialize, S: serde::Serializer>(
|
|
lock: &OnceLock<T>,
|
|
serializer: S,
|
|
) -> Result<S::Ok, S::Error> {
|
|
if let Some(val) = lock.get() {
|
|
val.serialize(serializer)
|
|
} else {
|
|
serializer.serialize_none()
|
|
}
|
|
}
|
|
|
|
pub fn is_once_lock_map_empty<K, V>(lock: &OnceLock<std::collections::BTreeMap<K, V>>) -> bool {
|
|
lock.get().map_or(true, |m| m.is_empty())
|
|
}
|
|
|
|
pub fn is_once_lock_vec_empty<T>(lock: &OnceLock<Vec<T>>) -> bool {
|
|
lock.get().map_or(true, |v| v.is_empty())
|
|
}
|
|
|
|
pub fn is_once_lock_string_empty(lock: &OnceLock<String>) -> bool {
|
|
lock.get().map_or(true, |s| s.is_empty())
|
|
}
|
|
|
|
// Schema mirrors the Go Punc Generator's schema struct for consistency.
|
|
// It is an order-preserving representation of a JSON Schema.
|
|
pub fn deserialize_some<'de, D>(deserializer: D) -> Result<Option<Value>, D::Error>
|
|
where
|
|
D: serde::Deserializer<'de>,
|
|
{
|
|
let v = Value::deserialize(deserializer)?;
|
|
Ok(Some(v))
|
|
}
|
|
|
|
pub fn is_primitive_type(t: &str) -> bool {
|
|
matches!(
|
|
t,
|
|
"string" | "number" | "integer" | "boolean" | "object" | "array" | "null"
|
|
)
|
|
}
|
|
|
|
impl SchemaObject {
|
|
pub fn get_discriminator_value(&self, dim: &str, schema_id: &str) -> Option<String> {
|
|
let is_split = self
|
|
.compiled_properties
|
|
.get()
|
|
.map_or(false, |p| p.contains_key("kind"));
|
|
|
|
if dim == "kind" {
|
|
let base = schema_id.split('/').last().unwrap_or(schema_id);
|
|
if let Some(idx) = base.rfind('.') {
|
|
return Some(base[..idx].to_string());
|
|
}
|
|
}
|
|
|
|
if dim == "type" {
|
|
let base = schema_id.split('/').last().unwrap_or(schema_id);
|
|
if is_split {
|
|
return Some(base.split('.').next_back().unwrap_or(base).to_string());
|
|
} else {
|
|
return Some(base.to_string());
|
|
}
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
pub fn requires_uuid_path(&self, db: &crate::database::Database) -> bool {
|
|
// 1. Explicitly defines "id" either directly or via inheritance/extension?
|
|
if self
|
|
.compiled_properties
|
|
.get()
|
|
.map_or(false, |p| p.contains_key("id"))
|
|
{
|
|
return true;
|
|
}
|
|
|
|
// 2. Implicit table-backed rule: Does its family boundary map directly to the global database catalog?
|
|
if let Some(family) = &self.family {
|
|
let base = family.split('.').next_back().unwrap_or(family);
|
|
if db.types.contains_key(base) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
false
|
|
}
|
|
}
|