How to customize serialization

[gudaoxuri]

I added the following test code (for processing strings), but it didn't work.

#[derive(Object, Serialize, Deserialize, Debug)]
struct TestReq {
    #[serde(with = "trim")]
    code: String,
}

pub struct Api;

#[OpenApi]
impl Api {
    #[oai(path = "/test", method = "post")]
    async fn test(&self, test_req: Json<TestReq>) -> Result<i32> {
       ...
    }
}

pub mod trim {
    use serde::{self, Deserialize, Deserializer, Serializer};

    pub fn serialize<S>(str: &str, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let s = str.trim();
        serializer.serialize_str(s)
    }

    pub fn deserialize<'de, D>(deserializer: D) -> Result<String, D::Error>
    where
        D: Deserializer<'de>,
    {
        let s = String::deserialize(deserializer)?;
        Ok(s.trim().to_string())
    }
}

[sunli829]

You cannot do this, poem-openapi does not use serde to support serialization, currently you can only define a new type and implement the poem_openapi::Type trait for it.

[gudaoxuri]

It works using the following, but there is a doubt.

What is the use of name schema_ref in Type , it seems that it can be set to any value.

#[derive(Object, Serialize, Deserialize, Debug)]
struct TestReq {
    code: TrimString,
}

pub struct Api;

#[OpenApi]
impl Api {
    #[oai(path = "/test", method = "post")]
    async fn test(&self, test_req: Json<TestReq>) -> Result<i32> {
      ...
    }
}


#[derive(Debug, Eq, PartialEq, Hash)]
pub struct TrimString(String);

impl Display for TrimString {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        Display::fmt(&self.0.trim(), f)
    }
}

impl Serialize for TrimString {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        serializer.serialize_str(&self.0)
    }
}

impl<'de> Deserialize<'de> for TrimString {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        Deserialize::deserialize(deserializer).map(TrimString)
    }
}

impl crate::web::poem_openapi::types::Type for TrimString {
    const IS_REQUIRED: bool = true;

    type RawValueType = Self;

    type RawElementValueType = Self;

    fn name() -> Cow<'static, str> {
        "trim_string".into()
    }

    fn schema_ref() -> poem_openapi::registry::MetaSchemaRef {
        poem_openapi::registry::MetaSchemaRef::Inline(Box::new(poem_openapi::registry::MetaSchema::new_with_format("string", "trim")))
    }

    fn as_raw_value(&self) -> Option<&Self::RawValueType> {
        Some(self)
    }

    fn raw_element_iter<'a>(&'a self) -> Box<dyn Iterator<Item = &'a Self::RawElementValueType> + 'a> {
        Box::new(self.as_raw_value().into_iter())
    }
}

impl crate::web::poem_openapi::types::ToJSON for TrimString {
    fn to_json(&self) -> Option<serde_json::Value> {
        self.0.to_json()
    }
}

impl crate::web::poem_openapi::types::ParseFromJSON for TrimString {
    fn parse_from_json(value: Option<serde_json::Value>) -> poem_openapi::types::ParseResult<Self> {
        let value = value.unwrap_or_default();
        if let serde_json::Value::String(value) = value {
            Ok(TrimString(value))
        } else {
            Err(poem_openapi::types::ParseError::expected_type(value))
        }
    }
}

[sunli829]

Let swagger ui know its type, which is defined in the OpenAPI spec.

Since TrimString is just a special String, you can forward some methods to the String implementation like this:

 fn schema_ref() -> poem_openapi::registry::MetaSchemaRef {
    String:: schema_ref()
}