Macro for generating extensions (#1)

scim-client/tests/directory_scimple/users_endpoint.rs

@@ -1,8 +1,7 @@
-use scim_protocol::generate_endpoint;
-use scim_protocol::protocol::Extensions;
 use scim_protocol::resource::enterprise_user::EnterpriseUser;
 use scim_protocol::resource::user::User;
 use scim_protocol::resource::ScimSchema;
+use scim_protocol::{generate_endpoint, generate_extension};
 
 generate_endpoint!(
     path = "/Users",
@@ -13,17 +12,12 @@ generate_endpoint!(
     extensions = UserExtensions,
 );
 
-// TODO: generate even this
-#[derive(Debug, Clone, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
-pub struct UserExtensions {
-    #[serde(rename = "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User")]
-    pub enterprise_user: EnterpriseUser,
-    #[serde(rename = "urn:mem:params:scim:schemas:extension:LuckyNumberExtension")]
-    pub lucky_number: LuckyNumber,
-}
-impl Extensions for UserExtensions {
-    const SCHEMA: &'static [&'static str] = &[EnterpriseUser::SCHEMA, LuckyNumber::SCHEMA];
-}
+generate_extension!(
+    extension UserExtensions {
+        enterprise_user: EnterpriseUser,
+        lucky_number: LuckyNumber,
+    }
+);
 
 #[derive(Debug, Clone, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
 #[serde(rename_all = "camelCase")]

scim-protocol/src/endpoint/users.rs

@@ -1,8 +1,7 @@
-use crate::generate_endpoint;
-use crate::protocol::{Extensions, NoExtensions};
+use crate::protocol::NoExtensions;
 use crate::resource::enterprise_user::EnterpriseUser;
 use crate::resource::user::User;
-use crate::resource::ScimSchema;
+use crate::{generate_endpoint, generate_extension};
 
 generate_endpoint!(
     path = "/Users",
@@ -22,12 +21,8 @@ generate_endpoint!(
     extensions = EnterpriseUserExtensions,
 );
 
-// TODO: generate even this
-#[derive(Debug, Clone, PartialEq, Eq, serde::Deserialize, serde::Serialize)]
-pub struct EnterpriseUserExtensions {
-    #[serde(rename = "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User")]
-    pub enterprise_user: EnterpriseUser,
-}
-impl Extensions for EnterpriseUserExtensions {
-    const SCHEMA: &'static [&'static str] = &[EnterpriseUser::SCHEMA];
-}
+generate_extension!(
+    extension EnterpriseUserExtensions {
+        enterprise_user: EnterpriseUser,
+    }
+);

scim-protocol/src/protocol/extensions/generate.rs

@@ -0,0 +1,140 @@
+#[macro_export]
+macro_rules! generate_extension {
+    (extension $name:ident {
+        $($var:ident: $type:ty),*
+        $(,)?
+    }) => {
+        #[derive(Debug, Clone, PartialEq, Eq)]
+        pub struct $name {
+            $(pub $var: $type),*
+        }
+        impl $crate::protocol::Extensions for $name {
+            const SCHEMA: &'static [&'static str] = &[$(
+                <$type as $crate::resource::ScimSchema>::SCHEMA
+            ),*];
+        }
+
+        impl<'de> serde::Deserialize<'de> for $name {
+            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+            where
+                D: serde::Deserializer<'de>,
+            {
+                #[allow(non_camel_case_types)]
+                enum Field {
+                    $($var),*
+                    // Ignore,
+                }
+                #[doc(hidden)]
+                struct FieldVisitor;
+                impl<'de> serde::de::Visitor<'de> for FieldVisitor {
+                    type Value = Field;
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                        std::fmt::Formatter::write_str(formatter, "field identifier")
+                    }
+                    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            // TODO: should this be case insensitive check?
+                            $(<$type as $crate::resource::ScimSchema>::SCHEMA => {
+                                Ok(Field::$var)
+                            })*
+                            _ => {
+                                return Err(E::unknown_field(value, FIELDS));
+                            }
+                            //_ => Ok(Field::Ignore),
+                        }
+                    }
+                    fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
+                    where
+                        E: serde::de::Error,
+                    {
+                        match value {
+                            // TODO: should this be case insensitive check?
+                            $(_ if value == <$type as $crate::resource::ScimSchema>::SCHEMA.as_bytes() => {
+                                Ok(Field::$var)
+                            })*
+                            _ => {
+                                return Err(E::unknown_field(&String::from_utf8_lossy(value), FIELDS));
+                            }
+                            //_ => Ok(Field::Ignore),
+                        }
+                    }
+                }
+                impl<'de> serde::Deserialize<'de> for Field {
+                    #[inline]
+                    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+                    where
+                        D: serde::Deserializer<'de>,
+                    {
+                        serde::Deserializer::deserialize_identifier(deserializer, FieldVisitor)
+                    }
+                }
+                struct Visitor;
+                impl<'de> serde::de::Visitor<'de> for Visitor {
+                    type Value = $name;
+                    fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
+                        std::fmt::Formatter::write_str(formatter, concat!("struct ", stringify!($name)))
+                    }
+
+                    #[inline]
+                    fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+                    where
+                        A: serde::de::MapAccess<'de>,
+                    {
+                        $(let mut $var: Option<$type> = None;)*
+                        while let Some(key) = serde::de::MapAccess::next_key::<Field>(&mut map)? {
+                            match key {
+                                $(Field::$var => {
+                                    if Option::is_some(&$var) {
+                                        return Err(<A::Error as serde::de::Error>::duplicate_field(
+                                            <$type as $crate::resource::ScimSchema>::SCHEMA,
+                                        ));
+                                    }
+                                    $var = Some(serde::de::MapAccess::next_value::<$type>(&mut map)?);
+                                })*
+                                /*Field::Ignore => {
+                                    let _ = serde::de::MapAccess::next_value::<serde::de::IgnoredAny>(&mut map)?;
+                                }*/
+                            }
+                        }
+                        $(let Some($var) = $var else {
+                            return Err(<A::Error as serde::de::Error>::missing_field(
+                                <$type as $crate::resource::ScimSchema>::SCHEMA,
+                            ));
+                        };)*
+
+                        Ok($name {
+                            $($var),*
+                        })
+                    }
+                }
+                const FIELDS: &'static [&'static str] = &[
+                    $(<$type as $crate::resource::ScimSchema>::SCHEMA),*
+                ];
+                serde::Deserializer::deserialize_struct(deserializer, stringify!($name), FIELDS, Visitor)
+            }
+        }
+
+        impl serde::Serialize for $name {
+            fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+            where
+                S: serde::Serializer,
+            {
+                #[allow(unused_mut)]
+                let mut state = serde::Serializer::serialize_struct(
+                    serializer,
+                    stringify!($name),
+                    <$name as $crate::protocol::Extensions>::SCHEMA.len(),
+                )?;
+                $(serde::ser::SerializeStruct::serialize_field(
+                    &mut state,
+                    <$type as $crate::resource::ScimSchema>::SCHEMA,
+                    &self.$var,
+                )?;)*
+                serde::ser::SerializeStruct::end(state)
+            }
+        }
+    };
+}

scim-protocol/src/protocol/extensions/mod.rs

@@ -0,0 +1,11 @@
+mod generate;
+
+use crate::generate_extension;
+
+pub trait Extensions {
+    const SCHEMA: &'static [&'static str];
+}
+
+generate_extension!(
+    extension NoExtensions {}
+);

scim-protocol/tests/rfc7643_section8/sec_8_1_minimal_user.rs

@@ -12,7 +12,7 @@ fn test_response() {
         external_id: None,
         meta: meta(),
         resource: user(),
-        extensions: NoExtensions,
+        extensions: NoExtensions {},
     };
     assert_eq!(expected, actual);
 }

scim-protocol/tests/rfc7643_section8/sec_8_2_full_user.rs

@@ -21,7 +21,7 @@ fn test_response() {
         external_id: Some("701984".to_string()),
         meta: meta(id),
         resource: user(),
-        extensions: NoExtensions,
+        extensions: NoExtensions {},
     };
     assert_eq!(expected, actual);
 }

scim-protocol/tests/rfc7643_section8/sec_8_4_group.rs

@@ -47,6 +47,6 @@ fn expected() -> GroupResponse {
                 },
             ],
         },
-        extensions: NoExtensions,
+        extensions: NoExtensions {},
     }
 }