polyxml 0.25.0__tar.gz → 0.27.0__tar.gz

{polyxml-0.25.0 → polyxml-0.27.0}/Cargo.lock

@@ -608,7 +608,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml"
-version = "0.25.0"
+version = "0.27.0"
 dependencies = [
  "criterion",
  "heck",
@@ -628,14 +628,14 @@ dependencies = [
 
 [[package]]
 name = "polyxml-c"
-version = "0.25.0"
+version = "0.27.0"
 dependencies = [
  "polyxml",
 ]
 
 [[package]]
 name = "polyxml-cli"
-version = "0.25.0"
+version = "0.27.0"
 dependencies = [
  "clap",
  "glob",
@@ -649,7 +649,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-js"
-version = "0.25.0"
+version = "0.27.0"
 dependencies = [
  "napi",
  "napi-build",
@@ -659,7 +659,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-python"
-version = "0.25.0"
+version = "0.27.0"
 dependencies = [
  "lexical-core",
  "polyxml",
@@ -669,7 +669,7 @@ dependencies = [
 
 [[package]]
 name = "polyxml-wasm"
-version = "0.25.0"
+version = "0.27.0"
 dependencies = [
  "polyxml",
  "quick-xml",

{polyxml-0.25.0 → polyxml-0.27.0}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/polyxml-core", "crates/polyxml-python"]
 
 [workspace.package]
-version = "0.25.0"
+version = "0.27.0"
 edition = "2021"
 rust-version = "1.80"
 license = "MIT"

{polyxml-0.25.0 → polyxml-0.27.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: polyxml
-Version: 0.25.0
+Version: 0.27.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License

{polyxml-0.25.0 → polyxml-0.27.0}/crates/polyxml-core/src/codegen/java/mod.rs

@@ -57,6 +57,9 @@ pub struct JavaOptions {
     pub emit_direct_codec: bool,
     /// Generate facet validation in compact constructors (default: true)
     pub validate_facets: bool,
+    /// Emit Jakarta Bean Validation annotations (adds an optional API dependency).
+    #[serde(default)]
+    pub bean_validation: bool,
     /// Emit top-level aliases for root elements (default: true)
     pub emit_root_aliases: bool,
     /// Custom header text to prepend to generated files (default: None)
@@ -72,6 +75,7 @@ impl Default for JavaOptions {
             emit_builder: false,
             emit_direct_codec: false,
             validate_facets: true,
+            bean_validation: false,
             emit_root_aliases: true,
             custom_header: None,
         }
@@ -345,6 +349,9 @@ impl JavaCodegen {
         out.push_str("import java.time.*;\n");
         out.push_str("import java.math.*;\n");
         out.push_str("import java.util.regex.Pattern;\n");
+        if self.options.bean_validation {
+            out.push_str("import jakarta.validation.constraints.*;\n");
+        }
 
         if self.options.backend.is_jackson() {
             out.push('\n');
@@ -454,6 +461,12 @@ impl JavaCodegen {
 
             let field_type = self.field_type(field);
 
+            let bean_annotations = self.bean_annotations(field).join(" ");
+            let bean_prefix = if bean_annotations.is_empty() {
+                String::new()
+            } else {
+                format!("{bean_annotations} ")
+            };
             if jackson {
                 let mut annotations = Vec::new();
                 // @JsonProperty
@@ -482,9 +495,12 @@ impl JavaCodegen {
                 }
 
                 let annotation_str = annotations.join(" ");
-                components.push(format!("{} {} {}", annotation_str, field_type, field_id));
+                components.push(format!(
+                    "{}{} {} {}",
+                    bean_prefix, annotation_str, field_type, field_id
+                ));
             } else {
-                components.push(format!("{} {}", field_type, field_id));
+                components.push(format!("{}{} {}", bean_prefix, field_type, field_id));
             }
 
             if self.options.validate_facets {
@@ -714,10 +730,26 @@ impl JavaCodegen {
         };
 
         // Build the value component with optional Jackson annotations
+        let mut value_field = crate::ir::FieldDef::new(
+            "value",
+            "value",
+            crate::ir::FieldKind::Text,
+            s.base_type.clone(),
+        );
+        value_field.facets = Some(s.facets.clone());
+        let bean_prefix = self.bean_annotations(&value_field).join(" ");
+        let bean_prefix = if bean_prefix.is_empty() {
+            String::new()
+        } else {
+            format!("{bean_prefix} ")
+        };
         let value_component = if jackson {
-            format!("@JsonValue @JacksonXmlText {} value", base_type)
+            format!(
+                "{bean_prefix}@JsonValue @JacksonXmlText {} value",
+                base_type
+            )
         } else {
-            format!("{} value", base_type)
+            format!("{bean_prefix}{} value", base_type)
         };
 
         if checks.is_empty() && !jackson {
@@ -758,6 +790,129 @@ impl JavaCodegen {
         let _ = writeln!(out, "{}}}", indent);
     }
 
+    fn bean_annotations(&self, field: &crate::ir::FieldDef) -> Vec<String> {
+        if !self.options.bean_validation {
+            return Vec::new();
+        }
+        let mut annotations = Vec::new();
+        let is_list = field.cardinality.is_list() || field.type_ref.is_list();
+        let is_optional = field.cardinality.is_optional() || field.nillable;
+        if !is_optional
+            && !matches!(
+                self.field_type(field).as_str(),
+                "boolean" | "byte" | "short" | "int" | "long" | "float" | "double"
+            )
+        {
+            // Java primitive fields cannot be null; reference fields can.
+            annotations.push("@NotNull".to_string());
+        }
+        if matches!(&field.type_ref, TypeRef::Named(_) | TypeRef::List(_)) {
+            annotations.push("@jakarta.validation.Valid".to_string());
+        }
+        let facets = field.facets.as_ref();
+        let Some(facets) = facets else {
+            return annotations;
+        };
+        let primitive = &field.type_ref;
+        let is_string = matches!(
+            primitive,
+            TypeRef::Primitive(
+                PrimitiveType::String
+                    | PrimitiveType::NormalizedString
+                    | PrimitiveType::Token
+                    | PrimitiveType::Name
+                    | PrimitiveType::NCName
+                    | PrimitiveType::QName
+                    | PrimitiveType::Language
+                    | PrimitiveType::NMTOKEN
+                    | PrimitiveType::NMTOKENS
+                    | PrimitiveType::AnyUri
+                    | PrimitiveType::Id
+                    | PrimitiveType::IdRef
+                    | PrimitiveType::IdRefs
+                    | PrimitiveType::Entity
+                    | PrimitiveType::Entities
+                    | PrimitiveType::GDay
+                    | PrimitiveType::GMonth
+                    | PrimitiveType::GYear
+                    | PrimitiveType::GYearMonth
+                    | PrimitiveType::GMonthDay
+            )
+        );
+        let is_numeric = matches!(
+            primitive,
+            TypeRef::Primitive(
+                PrimitiveType::Byte
+                    | PrimitiveType::Short
+                    | PrimitiveType::Int
+                    | PrimitiveType::Integer
+                    | PrimitiveType::Long
+                    | PrimitiveType::Decimal
+                    | PrimitiveType::UnsignedByte
+                    | PrimitiveType::UnsignedShort
+                    | PrimitiveType::UnsignedInt
+                    | PrimitiveType::UnsignedLong
+                    | PrimitiveType::PositiveInteger
+                    | PrimitiveType::NegativeInteger
+                    | PrimitiveType::NonPositiveInteger
+                    | PrimitiveType::NonNegativeInteger
+                    | PrimitiveType::Float
+                    | PrimitiveType::Double
+            )
+        );
+        if is_list || (is_string && !is_optional) {
+            if let Some(length) = facets.length {
+                annotations.push(format!("@Size(min = {length}, max = {length})"));
+            } else if facets.min_length.is_some() || facets.max_length.is_some() {
+                annotations.push(format!(
+                    "@Size(min = {}, max = {})",
+                    facets.min_length.unwrap_or(0),
+                    facets.max_length.unwrap_or(i32::MAX as usize)
+                ));
+            }
+        }
+        if is_string && !is_optional {
+            for pattern in &facets.patterns {
+                annotations.push(format!(
+                    "@jakarta.validation.constraints.Pattern(regexp = {pattern:?})"
+                ));
+            }
+        }
+        if is_numeric
+            && !is_list
+            && !is_optional
+            && !matches!(
+                primitive,
+                TypeRef::Primitive(PrimitiveType::Float | PrimitiveType::Double)
+            )
+        {
+            for (value, minimum, inclusive) in [
+                (facets.min_inclusive.as_ref(), true, true),
+                (facets.max_inclusive.as_ref(), false, true),
+                (facets.min_exclusive.as_ref(), true, false),
+                (facets.max_exclusive.as_ref(), false, false),
+            ] {
+                if let Some(value) = value {
+                    if inclusive && !matches!(primitive, TypeRef::Primitive(PrimitiveType::Decimal))
+                    {
+                        if let Ok(integer) = value.parse::<i64>() {
+                            annotations.push(format!(
+                                "@{}({integer})",
+                                if minimum { "Min" } else { "Max" }
+                            ));
+                            continue;
+                        }
+                    }
+                    let annotation = if minimum { "DecimalMin" } else { "DecimalMax" };
+                    annotations.push(format!(
+                        "@{annotation}(value = {value:?}, inclusive = {inclusive})"
+                    ));
+                }
+            }
+        }
+        annotations
+    }
+
     fn build_facet_checks(
         &self,
         var_name: &str,
@@ -789,6 +944,11 @@ impl JavaCodegen {
                     | PrimitiveType::IdRefs
                     | PrimitiveType::Entity
                     | PrimitiveType::Entities
+                    | PrimitiveType::GDay
+                    | PrimitiveType::GMonth
+                    | PrimitiveType::GYear
+                    | PrimitiveType::GYearMonth
+                    | PrimitiveType::GMonthDay
             ),
             _ => false,
         };

{polyxml-0.25.0 → polyxml-0.27.0}/crates/polyxml-core/src/codegen/java/models.rs

@@ -16,6 +16,13 @@ impl JavaCodegen {
         let implements = interface.map(|v| format!(", {v}")).unwrap_or_default();
         let ty_name = self.context.map_type_ref(ty);
         let _ = writeln!(out, "{indent}public {nested}final class {name} implements java.io.Serializable{implements} {{\n{indent}    private static final long serialVersionUID = 1L;");
+        if self.options.bean_validation {
+            let mut value_field = FieldDef::new("value", "value", FieldKind::Text, ty.clone());
+            value_field.facets = facets.cloned();
+            for annotation in self.bean_annotations(&value_field) {
+                let _ = writeln!(out, "{indent}    {annotation}");
+            }
+        }
         if self.options.backend.is_jackson() {
             let _ = writeln!(out, "{indent}    @JsonValue @JacksonXmlText");
         }
@@ -153,6 +160,9 @@ impl JavaCodegen {
         let own = &fields[fields.len() - s.fields.len()..];
         for (f, id) in own {
             self.emit_property_annotations(out, f, &format!("{indent}    "));
+            for annotation in self.bean_annotations(f) {
+                let _ = writeln!(out, "{indent}    {annotation}");
+            }
             let _ = writeln!(
                 out,
                 "{indent}    private {} {id} = {};",

{polyxml-0.25.0 → polyxml-0.27.0}/crates/polyxml-core/src/codegen/typescript/mod.rs

@@ -759,6 +759,11 @@ impl TypeScriptCodegen {
                     | PrimitiveType::IdRefs
                     | PrimitiveType::Entity
                     | PrimitiveType::Entities
+                    | PrimitiveType::GDay
+                    | PrimitiveType::GMonth
+                    | PrimitiveType::GYear
+                    | PrimitiveType::GYearMonth
+                    | PrimitiveType::GMonthDay
             ),
             _ => false,
         };
@@ -836,6 +841,11 @@ impl TypeScriptCodegen {
                     | PrimitiveType::NCName
                     | PrimitiveType::Language
                     | PrimitiveType::AnyUri
+                    | PrimitiveType::GDay
+                    | PrimitiveType::GMonth
+                    | PrimitiveType::GYear
+                    | PrimitiveType::GYearMonth
+                    | PrimitiveType::GMonthDay
             ),
             _ => false,
         };
@@ -909,6 +919,11 @@ impl TypeScriptCodegen {
                     | PrimitiveType::NCName
                     | PrimitiveType::Language
                     | PrimitiveType::AnyUri
+                    | PrimitiveType::GDay
+                    | PrimitiveType::GMonth
+                    | PrimitiveType::GYear
+                    | PrimitiveType::GYearMonth
+                    | PrimitiveType::GMonthDay
             ),
             _ => false,
         };

polyxml-0.27.0/crates/polyxml-core/src/converters.rs

@@ -0,0 +1,178 @@
+use crate::error::{PolyXmlError, Result};
+use crate::ir::PrimitiveType;
+use crate::schema::ScalarType;
+use crate::value::PolyValue;
+
+#[inline(always)]
+pub fn trim_bytes(mut b: &[u8]) -> &[u8] {
+    while let Some((first, rest)) = b.split_first() {
+        if first.is_ascii_whitespace() {
+            b = rest;
+        } else {
+            break;
+        }
+    }
+    while let Some((last, rest)) = b.split_last() {
+        if last.is_ascii_whitespace() {
+            b = rest;
+        } else {
+            break;
+        }
+    }
+    b
+}
+
+pub struct ValueConverter;
+
+impl ValueConverter {
+    pub fn parse_scalar(
+        scalar_type: &ScalarType,
+        bytes: &[u8],
+        field_name: &str,
+    ) -> Result<PolyValue> {
+        match scalar_type {
+            ScalarType::String => {
+                let s = std::str::from_utf8(bytes)?;
+                Ok(PolyValue::String(s.to_string()))
+            }
+            ScalarType::Int => {
+                let trimmed = trim_bytes(bytes);
+                let val: i64 =
+                    lexical_core::parse(trimmed).map_err(|_| PolyXmlError::ScalarParseError {
+                        field: field_name.to_string(),
+                        expected: "integer",
+                        value: String::from_utf8_lossy(bytes).to_string(),
+                    })?;
+                Ok(PolyValue::Int(val))
+            }
+            ScalarType::Float => {
+                let trimmed = trim_bytes(bytes);
+                let val: f64 =
+                    lexical_core::parse(trimmed).map_err(|_| PolyXmlError::ScalarParseError {
+                        field: field_name.to_string(),
+                        expected: "float",
+                        value: String::from_utf8_lossy(bytes).to_string(),
+                    })?;
+                Ok(PolyValue::Float(val))
+            }
+            ScalarType::Bool => {
+                let trimmed = trim_bytes(bytes);
+                match trimmed {
+                    b"true" | b"1" => Ok(PolyValue::Bool(true)),
+                    b"false" | b"0" => Ok(PolyValue::Bool(false)),
+                    _ => Err(PolyXmlError::ScalarParseError {
+                        field: field_name.to_string(),
+                        expected: "boolean ('true', 'false', '1', '0')",
+                        value: String::from_utf8_lossy(bytes).to_string(),
+                    }),
+                }
+            }
+            ScalarType::Decimal
+            | ScalarType::XmlDate
+            | ScalarType::XmlDateTime
+            | ScalarType::XmlTime
+            | ScalarType::XmlDuration
+            | ScalarType::Any => {
+                let s = std::str::from_utf8(trim_bytes(bytes))?;
+                Ok(PolyValue::String(s.to_string()))
+            }
+            ScalarType::XmlGregorian(kind) => {
+                let value = std::str::from_utf8(trim_bytes(bytes))?;
+                if !valid_gregorian(*kind, value.as_bytes()) {
+                    return Err(PolyXmlError::ScalarParseError {
+                        field: field_name.to_string(),
+                        expected: "XML Schema Gregorian partial date",
+                        value: value.to_string(),
+                    });
+                }
+                Ok(PolyValue::String(value.to_string()))
+            }
+        }
+    }
+}
+
+fn two_digits(bytes: &[u8]) -> Option<u8> {
+    if bytes.len() == 2 && bytes.iter().all(u8::is_ascii_digit) {
+        Some((bytes[0] - b'0') * 10 + bytes[1] - b'0')
+    } else {
+        None
+    }
+}
+
+fn valid_timezone(bytes: &[u8]) -> Option<&[u8]> {
+    if let Some(value) = bytes.strip_suffix(b"Z") {
+        return Some(value);
+    }
+    let split = bytes
+        .iter()
+        .rposition(|byte| *byte == b'+' || *byte == b'-')?;
+    let suffix = &bytes[split..];
+    if suffix.len() != 6 || suffix[3] != b':' {
+        return None;
+    }
+    let hours = two_digits(&suffix[1..3])?;
+    let minutes = two_digits(&suffix[4..6])?;
+    if hours > 14 || minutes > 59 || (hours == 14 && minutes != 0) {
+        return None;
+    }
+    Some(&bytes[..split])
+}
+
+fn valid_gregorian(kind: PrimitiveType, bytes: &[u8]) -> bool {
+    let has_timezone = bytes.ends_with(b"Z")
+        || bytes.contains(&b'+')
+        || (bytes.len() >= 6 && bytes[bytes.len() - 6] == b'-' && bytes[bytes.len() - 3] == b':');
+    let value = if has_timezone {
+        match valid_timezone(bytes) {
+            Some(value) => value,
+            None => return false,
+        }
+    } else {
+        bytes
+    };
+    match kind {
+        PrimitiveType::GDay => {
+            value.len() == 5
+                && value.starts_with(b"---")
+                && two_digits(&value[3..]).is_some_and(|day| (1..=31).contains(&day))
+        }
+        PrimitiveType::GMonth => {
+            value.len() == 4
+                && value.starts_with(b"--")
+                && two_digits(&value[2..]).is_some_and(|month| (1..=12).contains(&month))
+        }
+        PrimitiveType::GMonthDay => {
+            if value.len() != 7 || !value.starts_with(b"--") || value[4] != b'-' {
+                return false;
+            }
+            let (Some(month), Some(day)) = (two_digits(&value[2..4]), two_digits(&value[5..7]))
+            else {
+                return false;
+            };
+            let max_day = match month {
+                2 => 29,
+                4 | 6 | 9 | 11 => 30,
+                1 | 3 | 5 | 7 | 8 | 10 | 12 => 31,
+                _ => return false,
+            };
+            day >= 1 && day <= max_day
+        }
+        PrimitiveType::GYear => valid_year(value),
+        PrimitiveType::GYearMonth => {
+            if value.len() < 7 || value[value.len() - 3] != b'-' {
+                return false;
+            }
+            valid_year(&value[..value.len() - 3])
+                && two_digits(&value[value.len() - 2..])
+                    .is_some_and(|month| (1..=12).contains(&month))
+        }
+        _ => false,
+    }
+}
+
+fn valid_year(value: &[u8]) -> bool {
+    let digits = value.strip_prefix(b"-").unwrap_or(value);
+    digits.len() >= 4
+        && digits.iter().all(u8::is_ascii_digit)
+        && (digits.len() == 4 || digits[0] != b'0')
+}

{polyxml-0.25.0 → polyxml-0.27.0}/crates/polyxml-core/src/parser.rs

@@ -355,6 +355,14 @@ impl XmlDeserializer {
                                     }
                                 }
                                 ValueType::Nested(sub_schema) => {
+                                    if is_nil {
+                                        stack
+                                            .last_mut()
+                                            .unwrap()
+                                            .push_list_item(field_idx, PolyValue::Null);
+                                        unknown_depth = 1;
+                                        continue;
+                                    }
                                     let frame_schema = resolve_record_schema(
                                         sub_schema,
                                         e,
@@ -367,6 +375,12 @@ impl XmlDeserializer {
                                 _ => {}
                             },
                             ValueType::Nested(sub_schema) => {
+                                if is_nil {
+                                    stack.last_mut().unwrap().values[field_idx] =
+                                        Some(PolyValue::Null);
+                                    unknown_depth = 1;
+                                    continue;
+                                }
                                 let frame_schema = resolve_record_schema(
                                     sub_schema,
                                     e,
@@ -414,6 +428,13 @@ impl XmlDeserializer {
                                     stack.last_mut().unwrap().push_list_item(field_idx, val);
                                 }
                                 ValueType::Nested(sub_schema) => {
+                                    if is_nil {
+                                        stack
+                                            .last_mut()
+                                            .unwrap()
+                                            .push_list_item(field_idx, PolyValue::Null);
+                                        continue;
+                                    }
                                     let frame_schema =
                                         resolve_record_schema(sub_schema, e, &scope)?;
                                     let mut frame = StackFrame::new(frame_schema);
@@ -427,6 +448,11 @@ impl XmlDeserializer {
                                 _ => {}
                             },
                             ValueType::Nested(sub_schema) => {
+                                if is_nil {
+                                    stack.last_mut().unwrap().values[field_idx] =
+                                        Some(PolyValue::Null);
+                                    continue;
+                                }
                                 let frame_schema = resolve_record_schema(sub_schema, e, &scope)?;
                                 let mut frame = StackFrame::new(frame_schema);
                                 Self::parse_attributes(e, &mut frame)?;

{polyxml-0.25.0 → polyxml-0.27.0}/crates/polyxml-core/src/schema.rs

@@ -19,6 +19,7 @@ pub enum ScalarType {
     XmlDateTime,
     XmlTime,
     XmlDuration,
+    XmlGregorian(crate::ir::PrimitiveType),
     Any,
 }
 
@@ -218,6 +219,11 @@ impl ModelSchema {
                 PrimitiveType::DateTime => ScalarType::XmlDateTime,
                 PrimitiveType::Time => ScalarType::XmlTime,
                 PrimitiveType::Date => ScalarType::XmlDate,
+                PrimitiveType::GDay
+                | PrimitiveType::GMonth
+                | PrimitiveType::GYear
+                | PrimitiveType::GYearMonth
+                | PrimitiveType::GMonthDay => ScalarType::XmlGregorian(prim),
                 PrimitiveType::Int
                 | PrimitiveType::Integer
                 | PrimitiveType::NonPositiveInteger