Merge pull request async-graphql#1588 from edbo/uuid_validator

UUID validator

Author: sunli829

Cargo.toml

@@ -32,6 +32,7 @@ graphiql = ["handlebars"]
 altair = ["handlebars", "schemars"]
 playground = []
 raw_value = ["async-graphql-value/raw_value"]
+uuid-validator = ["uuid"]
 
 [[bench]]
 harness = false

derive/src/validators.rs

@@ -28,6 +28,22 @@ impl ToTokens for Number {
     }
 }
 
+#[derive(Clone, Debug, PartialEq)]
+pub enum UuidVersionValidation {
+    None,
+    Value(Lit),
+}
+
+impl FromMeta for UuidVersionValidation {
+    fn from_word() -> darling::Result<Self> {
+        Ok(UuidVersionValidation::None)
+    }
+
+    fn from_value(value: &Lit) -> darling::Result<Self> {
+        Ok(UuidVersionValidation::Value(value.clone()))
+    }
+}
+
 #[derive(FromMeta, Default, Clone)]
 pub struct Validators {
     #[darling(default)]
@@ -58,6 +74,8 @@ pub struct Validators {
     ip: bool,
     #[darling(default)]
     regex: Option<String>,
+    #[darling(default)]
+    uuid: Option<UuidVersionValidation>,
     #[darling(default, multiple)]
     custom: Vec<Expr>,
     #[darling(default)]
@@ -159,6 +177,21 @@ impl Validators {
             });
         }
 
+        if let Some(version_validation) = &self.uuid {
+            match version_validation {
+                UuidVersionValidation::None => {
+                    elem_validators.push(quote! {
+                        #crate_name::validators::uuid(__raw_value, None)
+                    });
+                }
+                UuidVersionValidation::Value(version) => {
+                    elem_validators.push(quote! {
+                        #crate_name::validators::uuid(__raw_value, Some(#version))
+                    });
+                }
+            }
+        }
+
         if !list_validators.is_empty() {
             codes.push(quote! {
                 if let ::std::option::Option::Some(__raw_value) = #crate_name::InputType::as_raw_value(#value) {

docs/en/src/input_value_validators.md

@@ -15,6 +15,7 @@
 - **url** is valid url.
 - **ip** is valid ip address.
 - **regex=RE** is match for the regex.
+- **uuid=V** the string or ID is a valid UUID with version `V`. You may omit `V` to accept any UUID version. 
 
 ```rust
 # extern crate async_graphql;

src/types/id.rs

@@ -18,6 +18,12 @@ use crate::{InputValueError, InputValueResult, Scalar, ScalarType, Value};
 #[serde(transparent)]
 pub struct ID(pub String);
 
+impl AsRef<str> for ID {
+    fn as_ref(&self) -> &str {
+        self.0.as_str()
+    }
+}
+
 impl Deref for ID {
     type Target = String;
 

src/validators/mod.rs

@@ -14,6 +14,8 @@ mod minimum;
 mod multiple_of;
 mod regex;
 mod url;
+#[cfg(feature = "uuid-validator")]
+mod uuid;
 
 pub use chars_max_length::chars_max_length;
 pub use chars_min_length::chars_min_length;
@@ -29,6 +31,8 @@ pub use min_length::min_length;
 pub use min_password_strength::min_password_strength;
 pub use minimum::minimum;
 pub use multiple_of::multiple_of;
+#[cfg(feature = "uuid-validator")]
+pub use uuid::uuid;
 
 pub use self::{regex::regex, url::url};
 use crate::{InputType, InputValueError};

src/validators/uuid.rs

@@ -0,0 +1,56 @@
+use uuid::Uuid;
+
+use crate::{InputType, InputValueError};
+
+pub fn uuid<T: AsRef<str> + InputType>(
+    value: &T,
+    version_option: Option<usize>,
+) -> Result<(), InputValueError<T>> {
+    match Uuid::try_parse(value.as_ref()) {
+        Ok(uuid) => {
+            if let Some(version) = version_option {
+                if uuid.get_version_num() != version {
+                    return Err(InputValueError::custom("UUID version mismatch"));
+                }
+            }
+            Ok(())
+        }
+        Err(_) => Err(InputValueError::custom("Invalid UUID")),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_uuid() {
+        assert!(uuid(&"94c59486-c302-4f43-abd7-a9c980ddab36".to_string(), None).is_ok());
+        assert!(
+            uuid(&"94c59486-c302-4f43-abd7-a9c980ddab3".to_string(), None).is_err_and(|e| {
+                let message = format!("{:?}", e);
+                println!("{}", message);
+                message.contains("Invalid UUID")
+            })
+        );
+    }
+
+    #[test]
+    fn test_uuid_version() {
+        assert!(uuid(&"94c59486-c302-4f43-abd7-a9c980ddab36".to_string(), Some(4)).is_ok());
+        assert!(
+            uuid(&"94c59486-c302-4f43-abd7-a9c980ddab3".to_string(), Some(4)).is_err_and(|e| {
+                let message = format!("{:?}", e);
+                println!("{}", message);
+                message.contains("Invalid UUID")
+            })
+        );
+        assert!(
+            uuid(&"94c59486-c302-5f43-abd7-a9c980ddab36".to_string(), Some(4)).is_err_and(|e| {
+                let message = format!("{:?}", e);
+                println!("{}", message);
+                message.contains("UUID version mismatch")
+            })
+        );
+    }
+}