Skip to content

Commit

Permalink
Support for ipnet crate + IpAddr (#544)
Browse files Browse the repository at this point in the history 
* Type for IpAddr

- so both ipv4 or ipv6 address can be used in single field/parameter

* Support for ipnet crate

* Use oneOf variant for types which support both IPv4 and IPv6
  • Loading branch information
@mzachar
mzachar authored Jun 6, 2023
1 parent 4b149b0 commit e5c19c7
Show file tree
Hide file tree
Showing 2 changed files with 78 additions and 111 deletions.
1 change: 1 addition & 0 deletions poem-openapi/Cargo.toml
View file
Original file line number Diff line number Diff line change
Expand Up @@ -66,6 +66,7 @@ url = { version = "2.2.2", optional = true }
bson = { version = "2.0.0", optional = true }
rust_decimal = { version = "1.22.0", optional = true }
humantime = { version = "2.1.0", optional = true }
ipnet = { version = "2.7.1", optional = true }

[dev-dependencies]
tokio = { workspace = true, features = ["macros", "rt-multi-thread"] }
Expand Down
188 changes: 77 additions & 111 deletions poem-openapi/src/types/external/ip.rs
View file
Original file line number Diff line number Diff line change
@@ -1,6 +1,6 @@
use std::{
borrow::Cow,
net::{Ipv4Addr, Ipv6Addr},
net::{IpAddr, Ipv4Addr, Ipv6Addr},
};

use poem::{http::HeaderValue, web::Field};
Expand All @@ -14,132 +14,98 @@ use crate::{
},
};

impl Type for Ipv4Addr {
const IS_REQUIRED: bool = true;

type RawValueType = Self;

type RawElementValueType = Self;

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

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

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 ParseFromJSON for Ipv4Addr {
fn parse_from_json(value: Option<Value>) -> ParseResult<Self> {
let value = value.unwrap_or_default();
if let Value::String(value) = value {
Ok(value.parse()?)
} else {
Err(ParseError::expected_type(value))
}
}
}

impl ParseFromParameter for Ipv4Addr {
fn parse_from_parameter(value: &str) -> ParseResult<Self> {
value.parse().map_err(ParseError::custom)
}
}

#[poem::async_trait]
impl ParseFromMultipartField for Ipv4Addr {
async fn parse_from_multipart(field: Option<Field>) -> ParseResult<Self> {
match field {
Some(field) => Ok(field.text().await?.parse()?),
None => Err(ParseError::expected_input()),
macro_rules! meta_scheme {
($format:literal,) => {
MetaSchema::new_with_format("string", $format)
};
($format:literal, $($oneof:ty),+) => {
MetaSchema {
one_of: vec![$(<$oneof as Type>::schema_ref()),+],
..MetaSchema::ANY
}
}
}

impl ToJSON for Ipv4Addr {
fn to_json(&self) -> Option<Value> {
Some(Value::String(self.to_string()))
}
};
}

impl ToHeader for Ipv4Addr {
fn to_header(&self) -> Option<HeaderValue> {
HeaderValue::from_str(&self.to_string()).ok()
}
}
macro_rules! impl_type_for_ip {
($(($ty:ty, $format:literal $(,)? $($oneof:ty),*)),*) => {
$(
impl Type for $ty {
const IS_REQUIRED: bool = true;

impl Type for Ipv6Addr {
const IS_REQUIRED: bool = true;
type RawValueType = Self;

type RawValueType = Self;
type RawElementValueType = Self;

type RawElementValueType = Self;
fn name() -> Cow<'static, str> {
format!("string({})", $format).into()
}

fn name() -> Cow<'static, str> {
"string(ipv6)".into()
}
fn schema_ref() -> MetaSchemaRef {
MetaSchemaRef::Inline(Box::new(meta_scheme!($format, $($oneof),*)))
}

fn schema_ref() -> MetaSchemaRef {
MetaSchemaRef::Inline(Box::new(MetaSchema::new_with_format("string", "ipv6")))
}
fn as_raw_value(&self) -> Option<&Self::RawValueType> {
Some(self)
}

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())
}
}

fn raw_element_iter<'a>(
&'a self,
) -> Box<dyn Iterator<Item = &'a Self::RawElementValueType> + 'a> {
Box::new(self.as_raw_value().into_iter())
}
}
impl ParseFromJSON for $ty {
fn parse_from_json(value: Option<Value>) -> ParseResult<Self> {
let value = value.unwrap_or_default();
if let Value::String(value) = value {
Ok(value.parse()?)
} else {
Err(ParseError::expected_type(value))
}
}
}

impl ParseFromJSON for Ipv6Addr {
fn parse_from_json(value: Option<Value>) -> ParseResult<Self> {
let value = value.unwrap_or_default();
if let Value::String(value) = value {
Ok(value.parse()?)
} else {
Err(ParseError::expected_type(value))
impl ParseFromParameter for $ty {
fn parse_from_parameter(value: &str) -> ParseResult<Self> {
value.parse().map_err(ParseError::custom)
}
}
}
}

impl ParseFromParameter for Ipv6Addr {
fn parse_from_parameter(value: &str) -> ParseResult<Self> {
value.parse().map_err(ParseError::custom)
}
}
#[poem::async_trait]
impl ParseFromMultipartField for $ty {
async fn parse_from_multipart(field: Option<Field>) -> ParseResult<Self> {
match field {
Some(field) => Ok(field.text().await?.parse()?),
None => Err(ParseError::expected_input()),
}
}
}

#[poem::async_trait]
impl ParseFromMultipartField for Ipv6Addr {
async fn parse_from_multipart(field: Option<Field>) -> ParseResult<Self> {
match field {
Some(field) => Ok(field.text().await?.parse()?),
None => Err(ParseError::expected_input()),
impl ToJSON for $ty {
fn to_json(&self) -> Option<Value> {
Some(Value::String(self.to_string()))
}
}
}
}

impl ToJSON for Ipv6Addr {
fn to_json(&self) -> Option<Value> {
Some(Value::String(self.to_string()))
impl ToHeader for $ty {
fn to_header(&self) -> Option<HeaderValue> {
HeaderValue::from_str(&self.to_string()).ok()
}
}
)*
}
}

impl ToHeader for Ipv6Addr {
fn to_header(&self) -> Option<HeaderValue> {
HeaderValue::from_str(&self.to_string()).ok()
}
}
impl_type_for_ip!(
(Ipv4Addr, "ipv4"),
(Ipv6Addr, "ipv6"),
(IpAddr, "ip", Ipv4Addr, Ipv6Addr)
);

#[cfg(feature = "ipnet")]
impl_type_for_ip!(
(ipnet::Ipv4Net, "ipv4net"),
(ipnet::Ipv6Net, "ipv6net"),
(ipnet::IpNet, "ipnet", ipnet::Ipv4Net, ipnet::Ipv6Net)
);

0 comments on commit e5c19c7

Please sign in to comment.