copy OpenapiType implementations and fix codegen reference

openapi_type/src/impls.rs

@@ -0,0 +1,321 @@
+use crate::{OpenapiSchema, OpenapiType};
+use indexmap::IndexMap;
+use openapiv3::{
+	AdditionalProperties, ArrayType, IntegerType, NumberFormat, NumberType, ObjectType, ReferenceOr, SchemaKind, StringType,
+	Type, VariantOrUnknownOrEmpty
+};
+use std::{
+	collections::{BTreeSet, HashMap, HashSet},
+	hash::BuildHasher,
+	num::{NonZeroU128, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize}
+};
+
+impl OpenapiType for () {
+	fn schema() -> OpenapiSchema {
+		OpenapiSchema::new(SchemaKind::Type(Type::Object(ObjectType {
+			additional_properties: Some(AdditionalProperties::Any(false)),
+			..Default::default()
+		})))
+	}
+}
+
+impl OpenapiType for bool {
+	fn schema() -> OpenapiSchema {
+		OpenapiSchema::new(SchemaKind::Type(Type::Boolean {}))
+	}
+}
+
+macro_rules! int_types {
+	($($int_ty:ty),*) => {$(
+		impl OpenapiType for $int_ty
+		{
+			fn schema() -> OpenapiSchema
+			{
+				OpenapiSchema::new(SchemaKind::Type(Type::Integer(IntegerType::default())))
+			}
+		}
+	)*};
+
+	(unsigned $($int_ty:ty),*) => {$(
+		impl OpenapiType for $int_ty
+		{
+			fn schema() -> OpenapiSchema
+			{
+				OpenapiSchema::new(SchemaKind::Type(Type::Integer(IntegerType {
+					minimum: Some(0),
+					..Default::default()
+				})))
+			}
+		}
+	)*};
+
+	(gtzero $($int_ty:ty),*) => {$(
+		impl OpenapiType for $int_ty
+		{
+			fn schema() -> OpenapiSchema
+			{
+				OpenapiSchema::new(SchemaKind::Type(Type::Integer(IntegerType {
+					minimum: Some(1),
+					..Default::default()
+				})))
+			}
+		}
+	)*};
+
+	(bits = $bits:expr, $($int_ty:ty),*) => {$(
+		impl OpenapiType for $int_ty
+		{
+			fn schema() -> OpenapiSchema
+			{
+				OpenapiSchema::new(SchemaKind::Type(Type::Integer(IntegerType {
+					format: VariantOrUnknownOrEmpty::Unknown(format!("int{}", $bits)),
+					..Default::default()
+				})))
+			}
+		}
+	)*};
+
+	(unsigned bits = $bits:expr, $($int_ty:ty),*) => {$(
+		impl OpenapiType for $int_ty
+		{
+			fn schema() -> OpenapiSchema
+			{
+				OpenapiSchema::new(SchemaKind::Type(Type::Integer(IntegerType {
+					format: VariantOrUnknownOrEmpty::Unknown(format!("int{}", $bits)),
+					minimum: Some(0),
+					..Default::default()
+				})))
+			}
+		}
+	)*};
+
+	(gtzero bits = $bits:expr, $($int_ty:ty),*) => {$(
+		impl OpenapiType for $int_ty
+		{
+			fn schema() -> OpenapiSchema
+			{
+				OpenapiSchema::new(SchemaKind::Type(Type::Integer(IntegerType {
+					format: VariantOrUnknownOrEmpty::Unknown(format!("int{}", $bits)),
+					minimum: Some(1),
+					..Default::default()
+				})))
+			}
+		}
+	)*};
+}
+
+int_types!(isize);
+int_types!(unsigned usize);
+int_types!(gtzero NonZeroUsize);
+int_types!(bits = 8, i8);
+int_types!(unsigned bits = 8, u8);
+int_types!(gtzero bits = 8, NonZeroU8);
+int_types!(bits = 16, i16);
+int_types!(unsigned bits = 16, u16);
+int_types!(gtzero bits = 16, NonZeroU16);
+int_types!(bits = 32, i32);
+int_types!(unsigned bits = 32, u32);
+int_types!(gtzero bits = 32, NonZeroU32);
+int_types!(bits = 64, i64);
+int_types!(unsigned bits = 64, u64);
+int_types!(gtzero bits = 64, NonZeroU64);
+int_types!(bits = 128, i128);
+int_types!(unsigned bits = 128, u128);
+int_types!(gtzero bits = 128, NonZeroU128);
+
+macro_rules! num_types {
+	($($num_ty:ty = $num_fmt:ident),*) => {$(
+		impl OpenapiType for $num_ty
+		{
+			fn schema() -> OpenapiSchema
+			{
+				OpenapiSchema::new(SchemaKind::Type(Type::Number(NumberType {
+					format: VariantOrUnknownOrEmpty::Item(NumberFormat::$num_fmt),
+					..Default::default()
+				})))
+			}
+		}
+	)*}
+}
+
+num_types!(f32 = Float, f64 = Double);
+
+macro_rules! str_types {
+	($($str_ty:ty),*) => {$(
+		impl OpenapiType for $str_ty
+		{
+			fn schema() -> OpenapiSchema
+			{
+				OpenapiSchema::new(SchemaKind::Type(Type::String(StringType::default())))
+			}
+		}
+	)*};
+
+	(format = $format:ident, $($str_ty:ty),*) => {$(
+		impl OpenapiType  for $str_ty
+		{
+			fn schema() -> OpenapiSchema
+			{
+				use openapiv3::StringFormat;
+
+				OpenapiSchema::new(SchemaKind::Type(Type::String(StringType {
+					format: VariantOrUnknownOrEmpty::Item(StringFormat::$format),
+					..Default::default()
+				})))
+			}
+		}
+	)*};
+
+	(format_str = $format:expr, $($str_ty:ty),*) => {$(
+		impl OpenapiType  for $str_ty
+		{
+			fn schema() -> OpenapiSchema
+			{
+				OpenapiSchema::new(SchemaKind::Type(Type::String(StringType {
+					format: VariantOrUnknownOrEmpty::Unknown($format.to_string()),
+					..Default::default()
+				})))
+			}
+		}
+	)*};
+}
+
+str_types!(String, &str);
+
+#[cfg(feature = "chrono")]
+str_types!(format = Date, Date<FixedOffset>, Date<Local>, Date<Utc>, NaiveDate);
+#[cfg(feature = "chrono")]
+str_types!(
+	format = DateTime,
+	DateTime<FixedOffset>,
+	DateTime<Local>,
+	DateTime<Utc>,
+	NaiveDateTime
+);
+
+#[cfg(feature = "uuid")]
+str_types!(format_str = "uuid", Uuid);
+
+impl<T: OpenapiType> OpenapiType for Option<T> {
+	fn schema() -> OpenapiSchema {
+		let schema = T::schema();
+		let mut dependencies = schema.dependencies.clone();
+		let schema = match schema.name.clone() {
+			Some(name) => {
+				let reference = ReferenceOr::Reference {
+					reference: format!("#/components/schemas/{}", name)
+				};
+				dependencies.insert(name, schema);
+				SchemaKind::AllOf { all_of: vec![reference] }
+			},
+			None => schema.schema
+		};
+
+		OpenapiSchema {
+			nullable: true,
+			name: None,
+			schema,
+			dependencies
+		}
+	}
+}
+
+impl<T: OpenapiType> OpenapiType for Vec<T> {
+	fn schema() -> OpenapiSchema {
+		let schema = T::schema();
+		let mut dependencies = schema.dependencies.clone();
+
+		let items = match schema.name.clone() {
+			Some(name) => {
+				let reference = ReferenceOr::Reference {
+					reference: format!("#/components/schemas/{}", name)
+				};
+				dependencies.insert(name, schema);
+				reference
+			},
+			None => ReferenceOr::Item(Box::new(schema.into_schema()))
+		};
+
+		OpenapiSchema {
+			nullable: false,
+			name: None,
+			schema: SchemaKind::Type(Type::Array(ArrayType {
+				items,
+				min_items: None,
+				max_items: None,
+				unique_items: false
+			})),
+			dependencies
+		}
+	}
+}
+
+impl<T: OpenapiType> OpenapiType for BTreeSet<T> {
+	fn schema() -> OpenapiSchema {
+		<Vec<T> as OpenapiType>::schema()
+	}
+}
+
+impl<T: OpenapiType, S: BuildHasher> OpenapiType for HashSet<T, S> {
+	fn schema() -> OpenapiSchema {
+		<Vec<T> as OpenapiType>::schema()
+	}
+}
+
+impl<K: OpenapiType, T: OpenapiType, S: BuildHasher> OpenapiType for HashMap<K, T, S> {
+	fn schema() -> OpenapiSchema {
+		let key_schema = K::schema();
+		let mut dependencies = key_schema.dependencies.clone();
+
+		let keys = match key_schema.name.clone() {
+			Some(name) => {
+				let reference = ReferenceOr::Reference {
+					reference: format!("#/components/schemas/{}", name)
+				};
+				dependencies.insert(name, key_schema);
+				reference
+			},
+			None => ReferenceOr::Item(Box::new(key_schema.into_schema()))
+		};
+
+		let schema = T::schema();
+		dependencies.extend(schema.dependencies.iter().map(|(k, v)| (k.clone(), v.clone())));
+
+		let items = Box::new(match schema.name.clone() {
+			Some(name) => {
+				let reference = ReferenceOr::Reference {
+					reference: format!("#/components/schemas/{}", name)
+				};
+				dependencies.insert(name, schema);
+				reference
+			},
+			None => ReferenceOr::Item(schema.into_schema())
+		});
+
+		let mut properties = IndexMap::new();
+		properties.insert("default".to_owned(), keys);
+
+		OpenapiSchema {
+			nullable: false,
+			name: None,
+			schema: SchemaKind::Type(Type::Object(ObjectType {
+				properties,
+				required: vec!["default".to_owned()],
+				additional_properties: Some(AdditionalProperties::Schema(items)),
+				..Default::default()
+			})),
+			dependencies
+		}
+	}
+}
+
+impl OpenapiType for serde_json::Value {
+	fn schema() -> OpenapiSchema {
+		OpenapiSchema {
+			nullable: true,
+			name: None,
+			schema: SchemaKind::Any(Default::default()),
+			dependencies: Default::default()
+		}
+	}
+}

openapi_type/src/lib.rs

@@ -9,6 +9,10 @@ pub use indexmap;
 pub use openapi_type_derive::OpenapiType;
 pub use openapiv3 as openapi;
 
+mod impls;
+#[doc(hidden)]
+pub mod private;
+
 use indexmap::IndexMap;
 use openapi::{Schema, SchemaData, SchemaKind};
 

openapi_type/src/private.rs

@@ -0,0 +1,12 @@
+use crate::OpenapiSchema;
+use indexmap::IndexMap;
+
+pub type Dependencies = IndexMap<String, OpenapiSchema>;
+
+pub fn add_dependencies(dependencies: &mut Dependencies, other: &mut Dependencies) {
+	while let Some((dep_name, dep_schema)) = other.pop() {
+		if !dependencies.contains_key(&dep_name) {
+			dependencies.insert(dep_name, dep_schema);
+		}
+	}
+}