Add object id handling and deserialization

Author: jcdyer

Cargo.toml

@@ -8,7 +8,7 @@ edition = "2018"
 
 [dependencies]
 serde = "^1.0.101"
+bson = "^0.14.0"
 
 [dev-dependencies]
-bson = "^0.14.0"
 serde = { version = "^1.0.101", features = ["derive"] }

src/de.rs

@@ -115,11 +115,13 @@ impl<'a, 'de: 'a> Deserializer<'de> for &'a mut BsonDeserializer<'de> {
     type Error = Error;
 
     fn deserialize_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
+        println!("deserialize any");
         match self.bson {
             BsonFragment::Key(_) => self.deserialize_identifier(visitor),
             BsonFragment::Element(bson) => match bson.bsontype {
                 BsonType::String => self.deserialize_str(visitor),
                 BsonType::Document => self.deserialize_map(visitor),
+                BsonType::ObjectId => self.deserialize_map(visitor),
             },
         }
     }
@@ -179,7 +181,9 @@ impl<'a, 'de: 'a> Deserializer<'de> for &'a mut BsonDeserializer<'de> {
         println!("deserialize string");
 
         match &self.bson {
-            BsonFragment::Element(bson) => visitor.visit_str(bson.as_str().ok_or(Error::MalformedDocument)?),
+            BsonFragment::Element(bson) => {
+                visitor.visit_str(bson.as_str().ok_or(Error::MalformedDocument)?)
+            }
             BsonFragment::Key(k) => visitor.visit_str(k),
         }
     }
@@ -215,12 +219,16 @@ impl<'a, 'de: 'a> Deserializer<'de> for &'a mut BsonDeserializer<'de> {
     }
 
     fn deserialize_map<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
-         self.bson.apply_element(|bson| {
-             println!("deserialize map");
-             let doc = bson.as_doc().ok_or(Error::MalformedDocument)?;
-             let mapper = BsonDocumentMap::new(doc.into_iter());
-             Ok(visitor.visit_map(mapper)?)
-         })
+        self.bson.apply_element(|bson| match bson.bsontype {
+            BsonType::Document => {
+                println!("deserialize map with type: {:?}", bson.bsontype);
+                let doc = bson.as_doc().ok_or(Error::MalformedDocument)?;
+                let mapper = BsonDocumentMap::new(doc.into_iter());
+                Ok(visitor.visit_map(mapper)?)
+            }
+            BsonType::ObjectId => visitor.visit_map(object_id::ObjectIdDeserializer::new(*bson)),
+            _ => Err(Error::MalformedDocument),
+        })
     }
 
     fn deserialize_tuple<V: Visitor<'de>>(
@@ -308,50 +316,285 @@ impl<'de> MapAccess<'de> for BsonDocumentMap<'de> {
     }
 }
 
+pub mod object_id {
+    // ObjectId handling
+
+    use serde::de::{DeserializeSeed, Deserializer, MapAccess, Visitor};
+
+    use super::Error;
+    use crate::{BsonType, RawBson};
+
+    pub static FIELD: &str = "$__bson_object_id";
+    pub static NAME: &str = "$__bson_ObjectId";
+
+    pub(super) struct ObjectIdDeserializer<'de> {
+        bson: RawBson<'de>,
+        visited: bool,
+    }
+
+    impl<'de> ObjectIdDeserializer<'de> {
+        pub(super) fn new(bson: RawBson<'de>) -> ObjectIdDeserializer<'de> {
+            ObjectIdDeserializer {
+                bson,
+                visited: false,
+            }
+        }
+    }
+
+    impl<'de> MapAccess<'de> for ObjectIdDeserializer<'de> {
+        type Error = Error;
+
+        fn next_key_seed<K>(
+            &mut self,
+            seed: K,
+        ) -> Result<Option<<K as DeserializeSeed<'de>>::Value>, Self::Error>
+        where
+            K: DeserializeSeed<'de>,
+        {
+            println!("object id next key");
+            if self.visited {
+                Ok(None)
+            } else {
+                self.visited = true;
+                seed.deserialize(ObjectIdFieldDeserializer).map(Some)
+            }
+        }
+
+        fn next_value_seed<V>(
+            &mut self,
+            seed: V,
+        ) -> Result<<V as DeserializeSeed<'de>>::Value, Self::Error>
+        where
+            V: DeserializeSeed<'de>,
+        {
+            println!("object id next value");
+
+            seed.deserialize(ObjectIdValueDeserializer(self.bson))
+        }
+    }
+
+    struct ObjectIdFieldDeserializer;
+
+    impl<'de> Deserializer<'de> for ObjectIdFieldDeserializer {
+        type Error = Error;
+
+        fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+        where
+            V: Visitor<'de>,
+        {
+            visitor.visit_borrowed_str(FIELD)
+        }
+
+        serde::forward_to_deserialize_any!(
+            bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
+            bytes byte_buf map struct option unit newtype_struct
+            ignored_any unit_struct tuple_struct tuple enum identifier
+        );
+    }
+
+    struct ObjectIdValueDeserializer<'de>(RawBson<'de>);
+
+    impl<'de> ObjectIdValueDeserializer<'de> {
+        fn new(bson: RawBson<'de>) -> ObjectIdValueDeserializer<'de> {
+            ObjectIdValueDeserializer(bson)
+        }
+    }
+
+    impl<'de> Deserializer<'de> for ObjectIdValueDeserializer<'de> {
+        type Error = Error;
+
+        fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
+        where
+            V: Visitor<'de>,
+        {
+            match self.0.bsontype {
+                BsonType::ObjectId => visitor.visit_borrowed_bytes(self.0.data),
+                _ => Err(Error::MalformedDocument),
+            }
+        }
+
+        serde::forward_to_deserialize_any!(
+            bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
+            bytes byte_buf map struct option unit newtype_struct
+            ignored_any unit_struct tuple_struct tuple enum identifier
+        );
+    }
+}
+
 #[cfg(test)]
-mod tests{
+mod tests {
     use std::collections::HashMap;
+
     use bson::{bson, doc, encode_document};
+    use serde::Deserialize;
 
-    use serde::{Deserialize};
     use super::from_bytes;
 
+    mod object_id {
+        use std::fmt;
+
+        use serde::de::{Deserialize, Deserializer, MapAccess, Visitor};
+        use serde::export::fmt::Error;
+        use serde::export::Formatter;
+
+        use crate::de::object_id;
+
+        #[derive(Debug)]
+        pub(super) struct ObjectId(Vec<u8>);
+
+        impl ObjectId {
+            pub(super) fn from_bytes(bytes: Vec<u8>) -> Option<ObjectId> {
+                if bytes.len() == 12 {
+                    Some(ObjectId(bytes))
+                } else {
+                    None
+                }
+            }
+        }
+
+        impl<'de> Deserialize<'de> for ObjectId {
+            fn deserialize<D>(deserializer: D) -> Result<ObjectId, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                struct ObjectIdVisitor;
+
+                impl<'de> Visitor<'de> for ObjectIdVisitor {
+                    type Value = ObjectId;
+
+                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                        formatter.write_str("a bson objectid")
+                    }
+
+                    fn visit_map<V>(self, mut visitor: V) -> Result<ObjectId, V::Error>
+                    where
+                        V: MapAccess<'de>,
+                    {
+                        let value = visitor.next_key::<ObjectIdKey>()?;
+                        if value.is_none() {
+                            return Err(serde::de::Error::custom(
+                                "No ObjectIdKey not found in synthesized struct",
+                            ));
+                        }
+                        let v: ObjectIdFromBytes = visitor.next_value()?;
+                        Ok(v.0)
+                    }
+                }
+
+                static FIELDS: [&str; 1] = [object_id::FIELD];
+                deserializer.deserialize_struct(object_id::NAME, &FIELDS, ObjectIdVisitor)
+            }
+        }
+
+        struct ObjectIdKey;
+
+        impl<'de> Deserialize<'de> for ObjectIdKey {
+            fn deserialize<D>(deserializer: D) -> Result<ObjectIdKey, D::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                struct FieldVisitor;
+
+                impl<'de> Visitor<'de> for FieldVisitor {
+                    type Value = ();
+
+                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                        formatter.write_str("a valid object id field")
+                    }
+
+                    fn visit_str<E: serde::de::Error>(self, s: &str) -> Result<(), E> {
+                        if s == super::super::object_id::FIELD {
+                            Ok(())
+                        } else {
+                            Err(serde::de::Error::custom(
+                                "field was not $__bson_object_id in synthesized object id struct",
+                            ))
+                        }
+                    }
+                }
+
+                deserializer.deserialize_identifier(FieldVisitor)?;
+                Ok(ObjectIdKey)
+            }
+        }
+
+        struct ObjectIdFromBytes(ObjectId);
+
+        impl<'de> Deserialize<'de> for ObjectIdFromBytes {
+            fn deserialize<D>(deserializer: D) -> Result<Self, <D as Deserializer<'de>>::Error>
+            where
+                D: Deserializer<'de>,
+            {
+                struct FieldVisitor;
+
+                impl<'de> Visitor<'de> for FieldVisitor {
+                    type Value = ObjectIdFromBytes;
+
+                    fn expecting(&self, formatter: &mut Formatter<'_>) -> Result<(), Error> {
+                        formatter.write_str("an object id of twelve bytes")
+                    }
+
+                    fn visit_bytes<E: serde::de::Error>(self, v: &[u8]) -> Result<Self::Value, E> {
+                        ObjectId::from_bytes(v.to_vec())
+                            .map(ObjectIdFromBytes)
+                            .ok_or(serde::de::Error::custom("invalid object id"))
+                    }
+                }
+
+                deserializer.deserialize_bytes(FieldVisitor)
+            }
+        }
+    }
+
     #[derive(Deserialize)]
     struct Person<'a> {
+        #[serde(rename = "_id")]
+        id: object_id::ObjectId,
         first_name: &'a str,
         last_name: String,
     }
 
     #[test]
     fn deserialize_struct() {
         let mut docbytes = Vec::new();
-        encode_document(&mut docbytes, &doc! {
-            "first_name": "Edward",
-            "last_name": "Teach",
-        }).expect("could not encode document");
-        let p: Person = super::from_bytes(&docbytes).expect("could not decode into Person struct");
+        encode_document(
+            &mut docbytes,
+            &doc! {
+                "_id": bson::oid::ObjectId::with_string("abcdefabcdefabcdefabcdef").unwrap(),
+                "first_name": "Edward",
+                "last_name": "Teach",
+            },
+        )
+        .expect("could not encode document");
+        let p: Person = from_bytes(&docbytes).expect("could not decode into Person struct");
         assert_eq!(p.first_name, "Edward");
         assert_eq!(p.last_name, "Teach");
     }
+
     #[test]
     fn deserialize_map() {
         let mut docbytes = Vec::new();
-        encode_document(&mut docbytes, &doc! {
-            "this": "that",
-            "three": "four",
-            "keymaster": "gatekeeper",
-        }).expect("could not encode document");
-        let map: HashMap<&str, &str> = super::from_bytes(&docbytes).expect("could not decode into HashMap<&str, &str>");
+        encode_document(
+            &mut docbytes,
+            &doc! {
+                "this": "that",
+                "three": "four",
+                "keymaster": "gatekeeper",
+            },
+        )
+        .expect("could not encode document");
+        let map: HashMap<&str, &str> =
+            from_bytes(&docbytes).expect("could not decode into HashMap<&str, &str>");
         assert_eq!(map.len(), 3);
         assert_eq!(*map.get("this").expect("key not found"), "that");
         assert_eq!(*map.get("three").expect("key not found"), "four");
         assert_eq!(*map.get("keymaster").expect("key not found"), "gatekeeper");
 
-        let map: HashMap<String, String> = super::from_bytes(&docbytes).expect("could not decode into HashMap<String, String>");
+        let map: HashMap<String, String> =
+            from_bytes(&docbytes).expect("could not decode into HashMap<String, String>");
         assert_eq!(map.len(), 3);
         assert_eq!(map.get("this").expect("key not found"), "that");
         assert_eq!(map.get("three").expect("key not found"), "four");
         assert_eq!(map.get("keymaster").expect("key not found"), "gatekeeper");
     }
-
 }