Optimize jni

Author: owjs3901

Cargo.lock

@@ -13,7 +13,11 @@
 //! - [`TryFromMultipartWithState<S>`] — Trait for parsing a full multipart request
 //! - [`TryFromFieldWithState<S>`] — Trait for parsing a single multipart field
 
-use std::{borrow::Cow, fmt};
+use std::{
+    borrow::Cow,
+    fmt,
+    sync::atomic::{AtomicUsize, Ordering},
+};
 
 use axum::extract::multipart::{Field, MultipartError, MultipartRejection};
 use axum::extract::{FromRequest, Request};
@@ -319,8 +323,28 @@ pub struct FieldMetadata {
     pub file_name: Option<String>,
     /// The MIME content type of the field.
     pub content_type: Option<String>,
-    /// All HTTP headers associated with this multipart part.
-    pub headers: axum::http::HeaderMap,
+    /// Full HTTP headers associated with this multipart part, when explicitly captured.
+    ///
+    /// Vespera's built-in parsers only need `name`, `file_name`, and `content_type`,
+    /// so the default `FieldData<T>` path no longer clones the whole `HeaderMap` for
+    /// every field. Use [`FieldMetadata::with_headers`] when constructing metadata
+    /// manually and the complete part header map is part of your API contract.
+    pub headers: Option<axum::http::HeaderMap>,
+}
+
+impl FieldMetadata {
+    /// Return the captured full multipart part headers, if they were collected.
+    #[must_use]
+    pub const fn headers(&self) -> Option<&axum::http::HeaderMap> {
+        self.headers.as_ref()
+    }
+
+    /// Attach a full header snapshot to existing metadata.
+    #[must_use]
+    pub fn with_headers(mut self, headers: axum::http::HeaderMap) -> Self {
+        self.headers = Some(headers);
+        self
+    }
 }
 
 impl From<&Field<'_>> for FieldMetadata {
@@ -329,7 +353,7 @@ impl From<&Field<'_>> for FieldMetadata {
             name: field.name().map(String::from),
             file_name: field.file_name().map(String::from),
             content_type: field.content_type().map(String::from),
-            headers: field.headers().clone(),
+            headers: None,
         }
     }
 }
@@ -531,9 +555,32 @@ const DEFAULT_STRING_FIELD_LIMIT_BYTES: usize = 1024 * 1024; // 1 MiB
 
 /// Default streaming cap for an **unannotated** `NamedTempFile` multipart field.
 ///
+/// The cap is intentionally larger than text fields: unannotated temp-file uploads
+/// are real file uploads, but still need a denial-of-service guard by default.
 /// Explicit `#[form_data(limit = "unlimited")]` continues to opt out by passing
-/// `usize::MAX` through the derive-generated parser.
-const DEFAULT_TEMP_FILE_FIELD_LIMIT_BYTES: usize = 1024 * 1024; // 1 MiB
+/// `usize::MAX` through the derive-generated parser. Applications can tune the
+/// process-wide default before handling requests with
+/// [`set_default_temp_file_field_limit_bytes`].
+pub const DEFAULT_TEMP_FILE_FIELD_LIMIT_BYTES: usize = 16 * 1024 * 1024; // 16 MiB
+
+static DEFAULT_TEMP_FILE_FIELD_LIMIT: AtomicUsize =
+    AtomicUsize::new(DEFAULT_TEMP_FILE_FIELD_LIMIT_BYTES);
+
+/// Return the current process-wide default cap for unannotated `NamedTempFile` fields.
+#[must_use]
+pub fn default_temp_file_field_limit_bytes() -> usize {
+    DEFAULT_TEMP_FILE_FIELD_LIMIT.load(Ordering::Relaxed)
+}
+
+/// Set the process-wide default cap for unannotated `NamedTempFile` fields.
+///
+/// Call this during application startup, before request handling begins. Per-field
+/// `#[form_data(limit = "...")]` annotations still take precedence, including the
+/// explicit `"unlimited"` opt-out. The previous cap is returned to support tests or
+/// embedders that need to restore their process setting.
+pub fn set_default_temp_file_field_limit_bytes(limit_bytes: usize) -> usize {
+    DEFAULT_TEMP_FILE_FIELD_LIMIT.swap(limit_bytes, Ordering::Relaxed)
+}
 
 impl<S: Send + Sync> TryFromFieldWithState<S> for String {
     async fn try_from_field_with_state(
@@ -684,7 +731,7 @@ impl<S: Send + Sync> TryFromFieldWithState<S> for tempfile::NamedTempFile {
         })?;
         let mut file = tokio::fs::File::from_std(std_file);
 
-        let limit_bytes = limit_bytes.unwrap_or(DEFAULT_TEMP_FILE_FIELD_LIMIT_BYTES);
+        let limit_bytes = limit_bytes.unwrap_or_else(default_temp_file_field_limit_bytes);
         let mut total = 0usize;
         while let Some(chunk) = field.chunk().await? {
             // `saturating_add` (matching `read_field_data`) prevents a

crates/vespera/src/multipart.rs

@@ -44,6 +44,38 @@ fn test_str_to_bool_trims_surrounding_whitespace() {
     assert_eq!(str_to_bool("   "), None);
 }
 
+#[test]
+fn field_metadata_full_headers_are_optional_by_default() {
+    let metadata = FieldMetadata {
+        name: Some("file".to_owned()),
+        file_name: Some("data.bin".to_owned()),
+        content_type: Some("application/octet-stream".to_owned()),
+        headers: None,
+    };
+
+    assert!(metadata.headers().is_none());
+}
+
+#[test]
+fn temp_file_default_limit_is_bounded_and_configurable() {
+    assert_eq!(
+        default_temp_file_field_limit_bytes(),
+        DEFAULT_TEMP_FILE_FIELD_LIMIT_BYTES
+    );
+    assert_eq!(DEFAULT_TEMP_FILE_FIELD_LIMIT_BYTES, 16 * 1024 * 1024);
+
+    let previous = set_default_temp_file_field_limit_bytes(2 * 1024 * 1024);
+    assert_eq!(previous, DEFAULT_TEMP_FILE_FIELD_LIMIT_BYTES);
+    assert_eq!(default_temp_file_field_limit_bytes(), 2 * 1024 * 1024);
+
+    let restored = set_default_temp_file_field_limit_bytes(previous);
+    assert_eq!(restored, 2 * 1024 * 1024);
+    assert_eq!(
+        default_temp_file_field_limit_bytes(),
+        DEFAULT_TEMP_FILE_FIELD_LIMIT_BYTES
+    );
+}
+
 // ─── Display tests for all error variants ───────────────────────────
 
 #[test]

crates/vespera/src/multipart/tests.rs

@@ -18,6 +18,7 @@ use ::std::io::{Read, Seek, SeekFrom};
 use ::std::sync::Once;
 use ::tokio::runtime::Builder;
 use ::vespera::axum::Json;
+use ::vespera::multipart::DEFAULT_TEMP_FILE_FIELD_LIMIT_BYTES;
 use ::vespera::multipart::{FieldData, TypedMultipart};
 use ::vespera::tempfile::NamedTempFile;
 use ::vespera::{Multipart, Schema, Validated};
@@ -399,7 +400,7 @@ fn named_temp_file_over_default_cap_rejected_413() {
         .build()
         .expect("tokio runtime");
 
-    let payload = vec![b'z'; 1024 * 1024 + 1];
+    let payload = vec![b'z'; DEFAULT_TEMP_FILE_FIELD_LIMIT_BYTES + 1];
     let wire = encode_multipart_upload_wire(
         "/capped-upload",
         "----TempFileCapBoundary",

crates/vespera/tests/multipart_wire.rs

@@ -1,6 +1,10 @@
 //! Schema-related structure definitions
 
-use serde::{Deserialize, Serialize, ser::SerializeStruct};
+use serde::{
+    Deserialize, Serialize,
+    de::MapAccess,
+    ser::{SerializeSeq, SerializeStruct},
+};
 use std::collections::BTreeMap;
 
 /// Schema reference or inline schema.
@@ -29,24 +33,51 @@ impl<'de> Deserialize<'de> for SchemaRef {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: serde::Deserializer<'de>,
+    {
+        deserializer.deserialize_map(SchemaRefVisitor)
+    }
+}
+
+struct SchemaRefVisitor;
+
+impl<'de> serde::de::Visitor<'de> for SchemaRefVisitor {
+    type Value = SchemaRef;
+
+    fn expecting(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        formatter.write_str("an OpenAPI schema reference or inline schema object")
+    }
+
+    fn visit_map<M>(self, mut access: M) -> Result<Self::Value, M::Error>
+    where
+        M: MapAccess<'de>,
     {
         use serde::de::Error as _;
-        // OpenAPI is always JSON; buffer the node so a *pure* reference
-        // can be distinguished from a `$ref` carrying sibling keywords.
-        let value = serde_json::Value::deserialize(deserializer)?;
-        // Pure reference: an object whose ONLY key is `$ref` with a string
-        // value.  A `$ref` with any sibling (`nullable`, `description`, …)
-        // is an inline schema, so the siblings are preserved instead of
-        // being dropped by the prior untagged `Ref`-first match.
-        if let serde_json::Value::Object(map) = &value
-            && map.len() == 1
-            && let Some(serde_json::Value::String(ref_path)) = map.get("$ref")
-        {
-            return Ok(Self::Ref(Reference::new(ref_path.clone())));
+
+        let mut ref_path = None;
+        let mut inline = serde_json::Map::new();
+        while let Some(key) = access.next_key::<String>()? {
+            let value = access.next_value::<serde_json::Value>()?;
+            if key == "$ref"
+                && ref_path.is_none()
+                && inline.is_empty()
+                && let serde_json::Value::String(path) = value
+            {
+                ref_path = Some(path);
+            } else {
+                if let Some(path) = ref_path.take() {
+                    inline.insert("$ref".to_owned(), serde_json::Value::String(path));
+                }
+                inline.insert(key, value);
+            }
+        }
+
+        if let Some(path) = ref_path {
+            return Ok(SchemaRef::Ref(Reference::new(path)));
         }
-        serde_json::from_value::<Schema>(value)
-            .map(|schema| Self::Inline(Box::new(schema)))
-            .map_err(D::Error::custom)
+
+        serde_json::from_value::<Schema>(serde_json::Value::Object(inline))
+            .map(|schema| SchemaRef::Inline(Box::new(schema)))
+            .map_err(M::Error::custom)
     }
 }
 
@@ -286,6 +317,74 @@ impl Serialize for NumberConstraint {
     }
 }
 
+struct NullableRefSchema<'a> {
+    ref_path: &'a str,
+}
+
+impl Serialize for NullableRefSchema<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut out = serializer.serialize_struct("Schema", 1)?;
+        out.serialize_field("$ref", self.ref_path)?;
+        out.end()
+    }
+}
+
+struct NullSchema;
+
+impl Serialize for NullSchema {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut out = serializer.serialize_struct("Schema", 1)?;
+        out.serialize_field("type", &SchemaType::Null)?;
+        out.end()
+    }
+}
+
+struct NullableRefAnyOf<'a> {
+    ref_path: &'a str,
+}
+
+impl Serialize for NullableRefAnyOf<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let mut seq = serializer.serialize_seq(Some(2))?;
+        seq.serialize_element(&NullableRefSchema {
+            ref_path: self.ref_path,
+        })?;
+        seq.serialize_element(&NullSchema)?;
+        seq.end()
+    }
+}
+
+struct ExamplesWithLegacy<'a> {
+    example: Option<&'a serde_json::Value>,
+    examples: &'a [serde_json::Value],
+}
+
+impl Serialize for ExamplesWithLegacy<'_> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: serde::Serializer,
+    {
+        let len = self.examples.len() + usize::from(self.example.is_some());
+        let mut seq = serializer.serialize_seq(Some(len))?;
+        if let Some(example) = self.example {
+            seq.serialize_element(example)?;
+        }
+        for example in self.examples {
+            seq.serialize_element(example)?;
+        }
+        seq.end()
+    }
+}
+
 #[derive(Deserialize, Serialize)]
 #[serde(untagged)]
 enum SchemaTypeWire {
@@ -430,13 +529,7 @@ impl Serialize for Schema {
         let mut out = serializer.serialize_struct("Schema", 42)?;
         if let Some(ref_path) = &self.ref_path {
             if nullable_ref {
-                out.serialize_field(
-                    "anyOf",
-                    &[
-                        SchemaRef::Ref(Reference::new(ref_path.clone())),
-                        SchemaRef::Inline(Box::new(Self::new(SchemaType::Null))),
-                    ],
-                )?;
+                out.serialize_field("anyOf", &NullableRefAnyOf { ref_path })?;
             } else {
                 out.serialize_field("$ref", ref_path)?;
             }
@@ -463,13 +556,22 @@ impl Serialize for Schema {
         }
         match (&self.example, &self.examples) {
             (Some(example), Some(examples)) => {
-                let mut combined_examples = Vec::with_capacity(examples.len() + 1);
-                combined_examples.push(example);
-                combined_examples.extend(examples);
-                out.serialize_field("examples", &combined_examples)?;
+                out.serialize_field(
+                    "examples",
+                    &ExamplesWithLegacy {
+                        example: Some(example),
+                        examples,
+                    },
+                )?;
             }
             (Some(example), None) => {
-                out.serialize_field("examples", &[example])?;
+                out.serialize_field(
+                    "examples",
+                    &ExamplesWithLegacy {
+                        example: Some(example),
+                        examples: &[],
+                    },
+                )?;
             }
             (None, Some(examples)) => {
                 out.serialize_field("examples", examples)?;

crates/vespera_core/src/schema.rs

@@ -98,6 +98,19 @@ fn schema_level_example_serializes_as_examples_array() {
     assert_eq!(value["examples"], serde_json::json!(["abc", "def"]));
 }
 
+#[test]
+fn schema_level_example_and_examples_serialization_is_byte_identical() {
+    let schema = Schema {
+        example: Some(serde_json::json!("abc")),
+        examples: Some(vec![serde_json::json!("def")]),
+        ..Schema::string()
+    };
+
+    let json = serde_json::to_string(&schema).unwrap();
+
+    assert_eq!(json, r#"{"type":"string","examples":["abc","def"]}"#);
+}
+
 #[test]
 fn schema_level_legacy_example_deserializes_for_round_trip_compatibility() {
     let schema: Schema = serde_json::from_value(serde_json::json!({
@@ -272,6 +285,18 @@ fn nullable_reference_emits_anyof_ref_and_null_only() {
     );
 }
 
+#[test]
+fn nullable_reference_serialization_is_byte_identical() {
+    let schema = Schema::nullable_reference("#/components/schemas/User".to_owned());
+
+    let json = serde_json::to_string(&schema).unwrap();
+
+    assert_eq!(
+        json,
+        r##"{"anyOf":[{"$ref":"#/components/schemas/User"},{"type":"null"}]}"##
+    );
+}
+
 #[test]
 fn nullable_primitive_emits_type_array_with_null() {
     let schema = Schema {