rawbson/
de.rs

1use serde::de::{self, DeserializeSeed, Deserializer, MapAccess, SeqAccess, Visitor};
2use serde::forward_to_deserialize_any;
3use serde::Deserialize;
4
5use std::convert::TryInto;
6use std::fmt::Debug;
7use std::num::TryFromIntError;
8
9use crate::{elem::Element, ArrayIter, Doc, DocBuf, DocIter, RawError};
10use bson::spec::ElementType;
11
12use object_id::RawObjectIdDeserializer;
13
14pub mod binary;
15pub mod datetime;
16pub mod js;
17pub mod object_id;
18pub mod regex;
19
20#[derive(Debug)]
21pub enum Error {
22    Eof,
23    TrailingData(Vec<u8>),
24    EncodingError,
25    MalformedDocument,
26    UnexpectedType,
27    Unimplemented,
28    IntConversion(TryFromIntError),
29    Internal(String),
30    NotFound,
31    TmPErroR,
32}
33
34impl From<TryFromIntError> for Error {
35    fn from(err: TryFromIntError) -> Error {
36        Error::IntConversion(err)
37    }
38}
39
40impl std::error::Error for Error {}
41
42impl std::fmt::Display for Error {
43    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
44        write!(f, "{:?}", self)
45    }
46}
47
48impl de::Error for Error {
49    fn custom<T: std::fmt::Display>(err: T) -> Error {
50        Error::Internal(format!("{}", err))
51    }
52}
53
54impl From<RawError> for Error {
55    fn from(val: RawError) -> Error {
56        match val {
57            RawError::Utf8EncodingError(_) => Error::EncodingError,
58            RawError::UnexpectedType => Error::UnexpectedType,
59            RawError::MalformedValue(_) => Error::MalformedDocument,
60        }
61    }
62}
63
64pub struct BsonDeserializer<'de> {
65    bson: Element<'de>,
66}
67
68impl<'de> BsonDeserializer<'de> {
69    #[deprecated(since = "0.2.0", note = "use from_doc(&docref) instead")]
70    pub fn from_docref(doc: &'de Doc) -> Self {
71        BsonDeserializer::from_rawbson(Element::new(ElementType::EmbeddedDocument, doc.as_bytes()))
72    }
73
74    pub fn from_doc(doc: &'de Doc) -> Self {
75        BsonDeserializer::from_rawbson(Element::new(ElementType::EmbeddedDocument, doc.as_bytes()))
76    }
77
78    pub fn from_rawbson(bson: Element<'de>) -> Self {
79        BsonDeserializer { bson }
80    }
81}
82
83#[deprecated(since = "0.2.0", note = "use from_doc(&docbuf) instead")]
84pub fn from_docbuf<'de, T>(rawdoc_buf: &'de DocBuf) -> Result<T, crate::de::Error>
85where
86    T: Deserialize<'de>,
87{
88    from_doc(rawdoc_buf)
89}
90
91pub fn from_doc<'de, T>(rawdoc: &'de Doc) -> Result<T, crate::de::Error>
92where
93    T: Deserialize<'de>,
94{
95    let mut de = crate::de::BsonDeserializer::from_doc(rawdoc);
96    T::deserialize(&mut de)
97}
98
99#[deprecated(since = "0.2.0", note = "use from_doc(&docref) instead")]
100pub fn from_docref<'de, T>(rawdoc: &'de Doc) -> Result<T, crate::de::Error>
101where
102    T: Deserialize<'de>,
103{
104    from_doc(rawdoc)
105}
106
107pub fn from_bytes<'de, T: 'de>(data: &'de [u8]) -> Result<T, crate::de::Error>
108where
109    T: Deserialize<'de>,
110{
111    let raw_document = Doc::new(data)?;
112    from_doc(raw_document)
113}
114
115impl<'a, 'de: 'a> Deserializer<'de> for &'a mut BsonDeserializer<'de> {
116    type Error = Error;
117
118    fn deserialize_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
119        match self.bson.element_type() {
120            ElementType::Double => self.deserialize_f64(visitor),
121            ElementType::String => self.deserialize_str(visitor),
122            ElementType::EmbeddedDocument => self.deserialize_map(visitor),
123            ElementType::Array => self.deserialize_seq(visitor),
124            ElementType::Binary => self.deserialize_bytes(visitor),
125            ElementType::Undefined => self.deserialize_unit(visitor),
126            ElementType::ObjectId => {
127                self.deserialize_struct(object_id::NAME, object_id::FIELDS, visitor)
128            }
129            ElementType::Boolean => self.deserialize_bool(visitor),
130            ElementType::DateTime => {
131                self.deserialize_struct(datetime::NAME, datetime::FIELDS, visitor)
132            }
133            ElementType::Null => self.deserialize_unit(visitor),
134            ElementType::DbPointer => Err(Error::Unimplemented), // deserialize (&str, ObjectId), or struct
135            ElementType::RegularExpression => {
136                self.deserialize_struct(regex::NAME, regex::FIELDS, visitor)
137            }
138            ElementType::JavaScriptCode => self.deserialize_str(visitor),
139            ElementType::Symbol => self.deserialize_str(visitor),
140            ElementType::JavaScriptCodeWithScope => {
141                self.deserialize_struct(js::WITH_SCOPE_NAME, js::WITH_SCOPE_FIELDS, visitor)
142            } // deserialize (&'str, Map) or struct
143            ElementType::Int32 => self.deserialize_i32(visitor),
144            ElementType::Timestamp => self.deserialize_u64(visitor),
145            ElementType::Int64 => self.deserialize_i64(visitor),
146            ElementType::MinKey => self.deserialize_unit(visitor),
147            ElementType::MaxKey => self.deserialize_unit(visitor),
148            ElementType::Decimal128 => self.deserialize_i128(visitor),
149        }
150    }
151
152    fn deserialize_bool<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
153        visitor.visit_bool(self.bson.as_bool()?)
154    }
155
156    #[cfg(feature = "u2i")]
157    fn deserialize_u8<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
158        let val = match self.bson.element_type() {
159            ElementType::Int32 => self.bson.as_i32()?.try_into()?,
160            ElementType::Int64 => self.bson.as_i64()?.try_into()?,
161            _ => return Err(Error::UnexpectedType),
162        };
163        visitor.visit_u8(val)
164    }
165
166    fn deserialize_i8<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
167        let val = match self.bson.element_type() {
168            ElementType::Int32 => self.bson.as_i32()?.try_into()?,
169            ElementType::Int64 => self.bson.as_i64()?.try_into()?,
170            _ => return Err(Error::UnexpectedType),
171        };
172        visitor.visit_i8(val)
173    }
174
175    #[cfg(feature = "u2i")]
176    fn deserialize_u16<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
177        let val = match self.bson.element_type() {
178            ElementType::Int32 => self.bson.as_i32()?.try_into()?,
179            ElementType::Int64 => self.bson.as_i64()?.try_into()?,
180            _ => return Err(Error::UnexpectedType),
181        };
182        visitor.visit_u16(val)
183    }
184    fn deserialize_i16<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
185        let val = match self.bson.element_type() {
186            ElementType::Int32 => self.bson.as_i32()?.try_into()?,
187            ElementType::Int64 => self.bson.as_i64()?.try_into()?,
188            _ => return Err(Error::UnexpectedType),
189        };
190        visitor.visit_i16(val)
191    }
192
193    #[cfg(feature = "u2i")]
194    fn deserialize_u32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
195        let val = match self.bson.element_type() {
196            ElementType::Int32 => self.bson.as_i32()?.try_into()?,
197            ElementType::Int64 => self.bson.as_i64()?.try_into()?,
198            _ => return Err(Error::UnexpectedType),
199        };
200        visitor.visit_u32(val)
201    }
202
203    fn deserialize_i32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
204        let val = match self.bson.element_type() {
205            ElementType::Int32 => self.bson.as_i32()?,
206            ElementType::Int64 => self.bson.as_i64()?.try_into()?,
207            _ => return Err(Error::UnexpectedType),
208        };
209        visitor.visit_i32(val)
210    }
211
212    #[cfg(feature = "u2i")]
213    fn deserialize_u64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
214        let val = match self.bson.element_type() {
215            ElementType::Int32 => self.bson.as_i32()?.try_into()?,
216            ElementType::Int64 => self.bson.as_i64()?.try_into()?,
217            ElementType::Timestamp => self.bson.as_timestamp()?,
218            ElementType::DateTime => self
219                .bson
220                .as_utc_date_time()?
221                .timestamp_millis()
222                .try_into()?,
223            _ => return Err(Error::UnexpectedType),
224        };
225        visitor.visit_u64(val)
226    }
227
228    fn deserialize_i64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
229        let val = match self.bson.element_type() {
230            ElementType::Int32 => self.bson.as_i32()?.into(),
231            ElementType::Int64 => self.bson.as_i64()?,
232            ElementType::DateTime => self.bson.as_datetime()?.timestamp_millis(),
233            _ => return Err(Error::UnexpectedType),
234        };
235        visitor.visit_i64(val)
236    }
237
238    fn deserialize_i128<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
239        let val = match self.bson.element_type() {
240            ElementType::Int32 => self.bson.as_i32()?.into(),
241            ElementType::Int64 => self.bson.as_i64()?.into(),
242            _ => return Err(Error::UnexpectedType),
243        };
244        visitor.visit_i128(val)
245    }
246
247    #[cfg(feature = "u2i")]
248    fn deserialize_u128<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
249        let val = match self.bson.element_type() {
250            ElementType::Int32 => self.bson.as_i32()?.try_into()?,
251            ElementType::Int64 => self.bson.as_i64()?.try_into()?,
252            ElementType::Timestamp => self.bson.as_timestamp()?.into(),
253            _ => return Err(Error::UnexpectedType),
254        };
255        visitor.visit_u128(val)
256    }
257
258    #[cfg(not(feature = "u2i"))]
259    fn deserialize_u8<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
260        Err(Error::MalformedDocument)
261    }
262
263    #[cfg(not(feature = "u2i"))]
264    fn deserialize_u16<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
265        Err(Error::MalformedDocument)
266    }
267
268    #[cfg(not(feature = "u2i"))]
269    fn deserialize_u32<V: Visitor<'de>>(self, _visitor: V) -> Result<V::Value, Self::Error> {
270        Err(Error::MalformedDocument)
271    }
272
273    #[cfg(not(feature = "u2i"))]
274    fn deserialize_u64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
275        let val = match self.bson.element_type() {
276            ElementType::Timestamp => self.bson.as_timestamp()?.time() as u64, // TODO: Proper Timestamp handling
277            ElementType::Int64 => self.bson.as_i64()?.try_into()?,
278            _ => return Err(Error::UnexpectedType),
279        };
280        visitor.visit_u64(val)
281    }
282
283    fn deserialize_f32<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
284        visitor.visit_f64(self.bson.as_f64()?)
285    }
286
287    fn deserialize_f64<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
288        visitor.visit_f64(self.bson.as_f64()?)
289    }
290
291    fn deserialize_char<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
292        let s = self.bson.as_str()?;
293        let mut chars = s.chars();
294        let char = match chars.next() {
295            Some(char) => char,
296            None => return Err(Error::UnexpectedType),
297        };
298        if chars.next().is_none() {
299            visitor.visit_char(char)
300        } else {
301            // Got multiple characters.
302            Err(Error::UnexpectedType)
303        }
304    }
305
306    fn deserialize_str<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
307        match self.bson.element_type() {
308            ElementType::String => visitor.visit_borrowed_str(self.bson.as_str()?),
309            ElementType::JavaScriptCode => visitor.visit_borrowed_str(self.bson.as_javascript()?),
310            ElementType::Symbol => visitor.visit_borrowed_str(self.bson.as_symbol()?),
311
312            _ => Err(Error::MalformedDocument),
313        }
314    }
315
316    fn deserialize_string<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
317        match self.bson.element_type() {
318            ElementType::String => visitor.visit_str(self.bson.as_str()?),
319            ElementType::JavaScriptCode => visitor.visit_str(self.bson.as_javascript()?),
320            ElementType::Symbol => visitor.visit_str(self.bson.as_symbol()?),
321            ElementType::ObjectId => visitor.visit_str(&self.bson.as_object_id()?.to_hex()),
322            _ => Err(Error::Unimplemented),
323        }
324    }
325
326    fn deserialize_bytes<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
327        match self.bson.element_type() {
328            ElementType::String => {
329                let raw_data = self.bson.as_bytes();
330                let len = i32::from_le_bytes(raw_data[0..4].try_into().expect("i32 needs 4 bytes"));
331                assert_eq!(raw_data.len(), len as usize + 4);
332                visitor.visit_borrowed_bytes(&raw_data[4..])
333            }
334            ElementType::Binary => {
335                let binary = self.bson.as_binary().expect("was not binary");
336                let deserializer = binary::BinaryDeserializer::new(binary);
337                deserializer.deserialize_bytes(visitor)
338            }
339            ElementType::Symbol => {
340                let raw_data = self.bson.as_bytes();
341                let len = i32::from_le_bytes(raw_data[0..4].try_into().expect("i32 needs 4 bytes"));
342                assert_eq!(raw_data.len(), len as usize + 4);
343                visitor.visit_borrowed_bytes(&raw_data[4..])
344            }
345            ElementType::ObjectId => visitor.visit_borrowed_bytes(self.bson.as_bytes()),
346            _ => Err(Error::MalformedDocument),
347        }
348    }
349
350    fn deserialize_byte_buf<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
351        match self.bson.element_type() {
352            ElementType::String => {
353                let raw_data = self.bson.as_bytes();
354                let len = i32::from_le_bytes(raw_data[0..4].try_into().expect("i32 needs 4 bytes"));
355                assert_eq!(raw_data.len(), len as usize + 4);
356                visitor.visit_bytes(&raw_data[4..])
357            }
358            ElementType::Binary => {
359                let binary = self.bson.as_binary()?;
360                let deserializer = binary::BinaryDeserializer::new(binary);
361                deserializer.deserialize_byte_buf(visitor)
362            }
363            ElementType::Symbol => {
364                let raw_data = self.bson.as_bytes();
365                let len = i32::from_le_bytes(raw_data[0..4].try_into().expect("i32 needs 4 bytes"));
366                assert_eq!(raw_data.len(), len as usize + 4);
367                visitor.visit_bytes(&raw_data[4..])
368            }
369            ElementType::ObjectId => visitor.visit_bytes(self.bson.as_bytes()),
370            _ => Err(Error::MalformedDocument),
371        }
372    }
373
374    fn deserialize_option<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
375        match self.bson.element_type() {
376            ElementType::Null => visitor.visit_none(),
377            _ => visitor.visit_some(self),
378        }
379    }
380
381    fn deserialize_unit<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
382        match self.bson.element_type() {
383            ElementType::Null => visitor.visit_unit(),
384            _ => Err(Error::MalformedDocument),
385        }
386    }
387
388    fn deserialize_unit_struct<V: Visitor<'de>>(
389        self,
390        _name: &str,
391        visitor: V,
392    ) -> Result<V::Value, Self::Error> {
393        self.deserialize_unit(visitor)
394    }
395
396    fn deserialize_newtype_struct<V: Visitor<'de>>(
397        self,
398        _name: &str,
399        visitor: V,
400    ) -> Result<V::Value, Self::Error> {
401        visitor.visit_newtype_struct(self)
402    }
403
404    fn deserialize_seq<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
405        match self.bson.element_type() {
406            ElementType::Array => {
407                let arr = self.bson.as_array()?;
408                let sequencer = BsonArraySequencer::new(arr.into_iter());
409                visitor.visit_seq(sequencer)
410            }
411            ElementType::ObjectId => self.deserialize_byte_buf(visitor),
412            _ => Err::<V::Value, Self::Error>(Error::Unimplemented),
413        }
414    }
415
416    fn deserialize_map<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
417        match self.bson.element_type() {
418            ElementType::EmbeddedDocument => {
419                let doc = self.bson.as_document()?;
420                let mapper = BsonDocumentMap::new(doc.into_iter());
421                visitor.visit_map(mapper)
422            }
423            ElementType::ObjectId => {
424                let mapper = RawObjectIdDeserializer::new(self.bson);
425                visitor.visit_map(mapper)
426            }
427            et => {
428                println!("Map of {:?}", et);
429                Err(Error::TmPErroR)
430            }
431        }
432    }
433
434    fn deserialize_tuple<V: Visitor<'de>>(
435        self,
436        len: usize,
437        visitor: V,
438    ) -> Result<V::Value, Self::Error> {
439        match self.bson.element_type() {
440            ElementType::Array => self.deserialize_seq(visitor),
441            ElementType::JavaScriptCodeWithScope => {
442                js::JavaScriptWithScopeDeserializer::new(self.bson.as_javascript_with_scope()?)
443                    .deserialize_tuple(len, visitor)
444            }
445            ElementType::RegularExpression => {
446                regex::RegexDeserializer::new(self.bson.as_regex()?).deserialize_tuple(len, visitor)
447            }
448
449            _ => Err(Error::TmPErroR),
450        }
451    }
452
453    fn deserialize_tuple_struct<V: Visitor<'de>>(
454        self,
455        _name: &str,
456        len: usize,
457        visitor: V,
458    ) -> Result<V::Value, Self::Error> {
459        self.deserialize_tuple(len, visitor)
460    }
461
462    fn deserialize_struct<V: Visitor<'de>>(
463        self,
464        name: &'static str,
465        fields: &'static [&'static str],
466        visitor: V,
467    ) -> Result<V::Value, Self::Error> {
468        if name == object_id::NAME {
469            object_id::RawObjectIdDeserializer::new(self.bson)
470                .deserialize_struct(name, fields, visitor)
471        } else if name == binary::NAME {
472            self.bson
473                .as_binary()
474                .map_err(Error::from)
475                .map(binary::BinaryDeserializer::new)
476                .and_then(|de| de.deserialize_struct(name, fields, visitor))
477        } else if name == datetime::NAME {
478            self.bson
479                .as_datetime()
480                .map_err(Error::from)
481                .map(|dt| dt.timestamp_millis())
482                .map(datetime::DateTimeDeserializer::new)
483                .and_then(|de| de.deserialize_struct(name, fields, visitor))
484        } else if name == js::WITH_SCOPE_NAME {
485            self.bson
486                .as_javascript_with_scope()
487                .map_err(Error::from)
488                .map(js::JavaScriptWithScopeDeserializer::new)
489                .and_then(|de| de.deserialize_struct(name, fields, visitor))
490        } else if name == regex::NAME {
491            self.bson
492                .as_regex()
493                .map_err(Error::from)
494                .map(regex::RegexDeserializer::new)
495                .and_then(|de| de.deserialize_struct(name, fields, visitor))
496        } else {
497            self.deserialize_map(visitor)
498        }
499    }
500
501    fn deserialize_enum<V: Visitor<'de>>(
502        self,
503        _name: &str,
504        _fields: &[&str],
505        _visitor: V,
506    ) -> Result<V::Value, Self::Error> {
507        Err(Error::Unimplemented)
508    }
509
510    fn deserialize_ignored_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
511        visitor.visit_unit()
512    }
513
514    fn deserialize_identifier<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
515        self.deserialize_str(visitor)
516    }
517}
518
519struct BsonArraySequencer<'de> {
520    arr_iter: ArrayIter<'de>,
521}
522
523impl<'de> BsonArraySequencer<'de> {
524    fn new(arr_iter: ArrayIter<'de>) -> Self {
525        BsonArraySequencer { arr_iter }
526    }
527}
528
529impl<'de> SeqAccess<'de> for BsonArraySequencer<'de> {
530    type Error = Error;
531
532    fn next_element_seed<E>(&mut self, seed: E) -> Result<Option<E::Value>, Self::Error>
533    where
534        E: DeserializeSeed<'de>,
535    {
536        match self.arr_iter.next() {
537            Some(Ok(bson)) => {
538                let mut deserializer = BsonDeserializer::from_rawbson(bson);
539                seed.deserialize(&mut deserializer).map(Some)
540            }
541            Some(Err(err)) => Err(err.into()),
542            None => Ok(None),
543        }
544    }
545}
546
547struct BsonDocumentMap<'de> {
548    doc_iter: DocIter<'de>,
549    next: Option<Element<'de>>,
550}
551
552impl<'de> BsonDocumentMap<'de> {
553    fn new(doc_iter: DocIter<'de>) -> Self {
554        BsonDocumentMap {
555            doc_iter,
556            next: None,
557        }
558    }
559}
560
561impl<'de> MapAccess<'de> for BsonDocumentMap<'de> {
562    type Error = Error;
563
564    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
565    where
566        K: DeserializeSeed<'de>,
567    {
568        match self.doc_iter.next() {
569            Some(Ok((key, value))) => {
570                self.next = Some(value);
571                let deserializer = StrDeserializer::new(key);
572                Ok(Some(seed.deserialize(deserializer)?))
573            }
574            Some(Err(err)) => Err(err.into()),
575            None => Ok(None),
576        }
577    }
578
579    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
580    where
581        V: DeserializeSeed<'de>,
582    {
583        let bson = self.next.take().ok_or(Error::Eof)?;
584        let mut deserializer = BsonDeserializer::from_rawbson(bson);
585        seed.deserialize(&mut deserializer)
586    }
587}
588
589struct StrDeserializer<'a> {
590    value: &'a str,
591}
592
593impl<'a> StrDeserializer<'a> {
594    fn new(value: &'a str) -> StrDeserializer<'a> {
595        StrDeserializer { value }
596    }
597}
598
599impl<'de> Deserializer<'de> for StrDeserializer<'de> {
600    type Error = Error;
601
602    fn deserialize_any<V: Visitor<'de>>(self, visitor: V) -> Result<V::Value, Self::Error> {
603        visitor.visit_borrowed_str(self.value)
604    }
605
606    forward_to_deserialize_any!(
607        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string seq
608        bytes byte_buf map struct option unit newtype_struct
609        ignored_any unit_struct tuple_struct tuple enum identifier
610    );
611}
612
613#[cfg(test)]
614mod tests {
615    use std::collections::HashMap;
616
617    use bson::{doc, oid::ObjectId, Bson, DateTime};
618    use bson::{spec::BinarySubtype, Binary, JavaScriptCodeWithScope};
619    use chrono::Utc;
620    use serde::Deserialize;
621    
622    use crate::{Doc, DocBuf};
623    use super::{from_bytes, from_doc};
624
625    mod uuid {
626        use std::convert::TryInto;
627        use std::fmt;
628        
629        use serde::de::Visitor;
630        use serde::de::{Deserialize, MapAccess};
631        use serde::Deserializer;
632
633        use bson::spec::BinarySubtype;
634        
635        #[derive(Clone, Debug, Eq, PartialEq)]
636        pub(super) struct Uuid {
637            data: Vec<u8>,
638        }
639
640        impl Uuid {
641            pub fn new(data: Vec<u8>) -> Uuid {
642                Uuid { data }
643            }
644        }
645
646        impl<'de> Deserialize<'de> for Uuid {
647            fn deserialize<D>(deserializer: D) -> Result<Self, <D as Deserializer<'de>>::Error>
648            where
649                D: Deserializer<'de>,
650            {
651                struct UuidVisitor;
652
653                impl<'de> Visitor<'de> for UuidVisitor {
654                    type Value = Uuid;
655
656                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
657                        formatter.write_str("a bson uuid")
658                    }
659
660                    fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>
661                    where
662                        M: MapAccess<'de>,
663                    {
664                        let subtype_key = map.next_key::<FieldKey>()?;
665                        if subtype_key.map(|dk| dk.key) != Some(super::super::binary::SUBTYPE_FIELD)
666                        {
667                            return Err(serde::de::Error::custom(
668                                "BinarySubtypeKey not found in synthesized struct",
669                            ));
670                        }
671
672                        let subtype_value: BinarySubtypeFromU8 = map.next_value()?;
673                        match subtype_value.subtype {
674                            BinarySubtype::Uuid | BinarySubtype::UuidOld => {}
675                            _ => {
676                                return Err(serde::de::Error::custom(
677                                    "Expected binary subtype of Uuid (4) or UuidOld (3)",
678                                ))
679                            }
680                        }
681
682                        let data_key = map.next_key::<FieldKey>()?;
683
684                        if data_key.map(|dk| dk.key) != Some(super::super::binary::DATA_FIELD) {
685                            return Err(serde::de::Error::custom(
686                                "BinaryDataKey not found in synthesized struct",
687                            ));
688                        }
689                        let data_value: BinaryDataFromBytes = map.next_value()?;
690                        Ok(Uuid {
691                            data: data_value.data,
692                        })
693                    }
694                }
695                static FIELDS: [&str; 2] = [
696                    super::super::binary::SUBTYPE_FIELD,
697                    super::super::binary::DATA_FIELD,
698                ];
699                deserializer.deserialize_struct(super::super::binary::NAME, &FIELDS, UuidVisitor)
700            }
701        }
702
703        struct FieldKey {
704            key: &'static str,
705        }
706
707        impl FieldKey {
708            fn new(key: &'static str) -> FieldKey {
709                FieldKey { key }
710            }
711        }
712
713        impl<'de> Deserialize<'de> for FieldKey {
714            fn deserialize<D>(deserializer: D) -> Result<Self, <D as Deserializer<'de>>::Error>
715            where
716                D: Deserializer<'de>,
717            {
718                struct KeyVisitor;
719
720                impl<'de> Visitor<'de> for KeyVisitor {
721                    type Value = FieldKey;
722
723                    fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
724                        formatter.write_str("an identifier")
725                    }
726
727                    fn visit_str<E: serde::de::Error>(self, s: &str) -> Result<FieldKey, E> {
728                        use super::super::binary::{DATA_FIELD, SUBTYPE_FIELD};
729                        if s == SUBTYPE_FIELD {
730                            Ok(FieldKey::new(SUBTYPE_FIELD))
731                        } else if s == DATA_FIELD {
732                            Ok(FieldKey::new(DATA_FIELD))
733                        } else {
734                            Err(serde::de::Error::custom(format!("unexpected field: {}", s)))
735                        }
736                    }
737                }
738
739                deserializer.deserialize_identifier(KeyVisitor)
740            }
741        }
742
743        struct BinarySubtypeFromU8 {
744            subtype: BinarySubtype,
745        }
746
747        impl BinarySubtypeFromU8 {
748            fn new(subtype_byte: u8) -> BinarySubtypeFromU8 {
749                let subtype = BinarySubtype::from(subtype_byte);
750                BinarySubtypeFromU8 { subtype }
751            }
752        }
753
754        impl<'de> Deserialize<'de> for BinarySubtypeFromU8 {
755            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
756            where
757                D: Deserializer<'de>,
758            {
759                struct SubtypeVisitor;
760
761                impl<'de> Visitor<'de> for SubtypeVisitor {
762                    type Value = BinarySubtypeFromU8;
763
764                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
765                        formatter.write_str("a u8 representing a binary subtype")
766                    }
767
768                    fn visit_u8<E: serde::de::Error>(
769                        self,
770                        byte: u8,
771                    ) -> Result<BinarySubtypeFromU8, E> {
772                        Ok(BinarySubtypeFromU8::new(byte))
773                    }
774                    fn visit_i32<E: serde::de::Error>(
775                        self,
776                        int: i32,
777                    ) -> Result<BinarySubtypeFromU8, E> {
778                        Ok(BinarySubtypeFromU8::new(
779                            int.try_into().map_err(|_| E::custom("non-byte integer"))?,
780                        ))
781                    }
782                }
783
784                deserializer.deserialize_u8(SubtypeVisitor)
785            }
786        }
787
788        struct BinaryDataFromBytes {
789            data: Vec<u8>,
790        }
791
792        impl BinaryDataFromBytes {
793            fn new(data: Vec<u8>) -> BinaryDataFromBytes {
794                BinaryDataFromBytes { data }
795            }
796        }
797
798        impl<'de> Deserialize<'de> for BinaryDataFromBytes {
799            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
800            where
801                D: Deserializer<'de>,
802            {
803                struct DataVisitor;
804
805                impl<'de> Visitor<'de> for DataVisitor {
806                    type Value = BinaryDataFromBytes;
807
808                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
809                        formatter.write_str("bytes")
810                    }
811
812                    fn visit_bytes<E: serde::de::Error>(
813                        self,
814                        bytes: &[u8],
815                    ) -> Result<BinaryDataFromBytes, E> {
816                        Ok(BinaryDataFromBytes::new(bytes.to_vec()))
817                    }
818                }
819
820                deserializer.deserialize_bytes(DataVisitor)
821            }
822        }
823    }
824
825    #[derive(Debug, Deserialize)]
826    struct Person<'a> {
827        #[serde(rename = "_id")]
828        id: ObjectId,
829        first_name: &'a str,
830        middle_name: Option<String>,
831        last_name: String,
832        number: &'a [u8],
833        gid: uuid::Uuid,
834        has_cookies: bool,
835        birth_year: Option<f64>,
836    }
837
838    #[test]
839    fn deserialize_struct() {
840        let mut docbytes = Vec::new();
841        let doc = doc! {
842            "_id": ObjectId::with_string("abcdefabcdefabcdefabcdef").unwrap(),
843            "first_name": "Edward",
844            "middle_name": Bson::Null,
845            "last_name": "Teach",
846            "number": Binary { subtype: BinarySubtype::Generic, bytes: vec![8, 6, 7, 5, 3, 0, 9] },
847            "has_cookies": false,
848            "gid": Binary { subtype: BinarySubtype::Uuid, bytes: b"12345678901234567890123456789012".to_vec() },
849            "birth_year": 15.0,
850        };
851        doc.to_writer(&mut docbytes)
852            .expect("could not encode document");
853        let p: Person = from_bytes(&docbytes).expect("could not decode into Person struct");
854        assert_eq!(p.first_name, "Edward");
855        assert_eq!(p.middle_name, None);
856        assert_eq!(p.last_name, "Teach");
857        assert_eq!(p.id.to_hex(), "abcdefabcdefabcdefabcdef");
858        assert_eq!(p.number, &[8, 6, 7, 5, 3, 0, 9]);
859        assert_eq!(p.has_cookies, false);
860        assert_eq!(
861            p.gid,
862            uuid::Uuid::new(b"12345678901234567890123456789012".to_vec())
863        );
864        assert_eq!(p.birth_year, Some(15.0));
865    }
866
867    #[test]
868    fn object_id() {
869        let object_id = ObjectId::new();
870        let doc = doc! {
871            "oid": object_id.clone(),
872        };
873        let mut docbytes = Vec::new();
874        doc.to_writer(&mut docbytes)
875            .expect("cannot serialize document");
876        let as_object: HashMap<String, ObjectId> =
877            from_bytes(&docbytes).expect("deserialize object_id");
878        assert_eq!(as_object.get("oid").unwrap(), &object_id);
879        let as_string: HashMap<String, String> = from_bytes(&docbytes).expect("deserialize string");
880        assert_eq!(as_string.get("oid").unwrap(), &object_id.to_hex());
881        let as_bytes: HashMap<String, &[u8]> =
882            from_bytes(&docbytes).expect("deserialize borrowed bytes");
883        assert_eq!(as_bytes.get("oid").unwrap(), &object_id.bytes());
884    }
885
886    #[test]
887    fn wrong_binary_type_for_uuid() {
888        let mut docbytes = Vec::new();
889        let doc = &doc! {
890            "_id": ObjectId::with_string("abcdefabcdefabcdefabcdef").unwrap(),
891            "first_name": "Edward",
892            "last_name": "Teach",
893            "has cookies": true,
894            "number": Binary { subtype: BinarySubtype::BinaryOld, bytes: vec![7, 0, 0, 0, 8, 6, 7, 5, 3, 0, 9] },
895            "gid": Binary { subtype: BinarySubtype::Function, bytes: b"12345678901234567890123456789012".to_vec() },
896        };
897        doc.to_writer(&mut docbytes)
898            .expect("could not encode document");
899
900        from_bytes::<Person>(&docbytes).expect_err("Should have failed to decode gid field");
901    }
902
903    #[test]
904    fn deserialize_map() {
905        let mut docbytes = Vec::new();
906        let doc = doc! {
907            "this": "that",
908            "three": "four",
909            "keymaster": "gatekeeper",
910        };
911        doc.to_writer(&mut docbytes)
912            .expect("could not encode document");
913
914        let map: HashMap<&str, &str> =
915            from_bytes(&docbytes).expect("could not decode into HashMap<&str, &str>");
916        assert_eq!(map.len(), 3);
917        assert_eq!(*map.get("this").expect("key not found"), "that");
918        assert_eq!(*map.get("three").expect("key not found"), "four");
919        assert_eq!(*map.get("keymaster").expect("key not found"), "gatekeeper");
920
921        let map: HashMap<String, String> =
922            from_bytes(&docbytes).expect("could not decode into HashMap<String, String>");
923        assert_eq!(map.len(), 3);
924        assert_eq!(map.get("this").expect("key not found"), "that");
925        assert_eq!(map.get("three").expect("key not found"), "four");
926        assert_eq!(map.get("keymaster").expect("key not found"), "gatekeeper");
927    }
928
929    #[test]
930    fn deserialize_seq() {
931        let mut docbytes = Vec::new();
932        let doc = doc! {"array": [1i32, 2i64, 3i32, "abc"]};
933        doc.to_writer(&mut docbytes)
934            .expect("could not encode document");
935        let map: HashMap<String, Vec<Bson>> =
936            from_bytes(&docbytes).expect("could not decode into HashMap<String, Vec<Bson>");
937        assert_eq!(map.len(), 1);
938        let arr = map.get("array").expect("key not found");
939        assert_eq!(arr.get(0).expect("no index 0"), &Bson::Int32(1));
940        assert_eq!(arr.get(1).expect("no index 1"), &Bson::Int64(2));
941        assert_eq!(arr.get(2).expect("no index 2"), &Bson::Int32(3));
942        assert_eq!(arr.get(3).expect("no index 3"), &Bson::String("abc".into()));
943        assert!(arr.get(4).is_none());
944    }
945
946    #[test]
947    fn deserialize_js_with_scope() {
948        let mut docbytes = Vec::new();
949        let doc = doc! {"js_with_scope": JavaScriptCodeWithScope {
950            code: String::from("console.log(value);"),
951            scope: doc!{"value": "Hello world"},
952        }};
953        doc.to_writer(&mut docbytes)
954            .expect("could not encode document");
955
956        let rawdoc = Doc::new(&docbytes).expect("Invalid document");
957        assert!(rawdoc.get_javascript_with_scope("js_with_scope").is_ok());
958        let map: HashMap<&str, (&str, HashMap<&str, &str>)> =
959            from_doc(rawdoc).expect("could not decode js with scope");
960        assert_eq!(
961            map.get("js_with_scope").expect("no key js_with_scope").0,
962            "console.log(value);"
963        );
964        assert_eq!(
965            map.get("js_with_scope")
966                .expect("no key js_with_scope")
967                .1
968                .get("value")
969                .expect("no key value"),
970            &"Hello world",
971        );
972    }
973
974    #[test]
975    fn deserialize_regexp() {
976        let mut docbytes = Vec::new();
977        let doc = doc! {"regex": bson::Regex { pattern: String::from("^_id$"), options: String::from("i") } };
978        doc.to_writer(&mut docbytes)
979            .expect("could not encode document");
980        let rawdoc = Doc::new(&docbytes).expect("Invalid document");
981        assert!(rawdoc.get_regex("regex").is_ok());
982        let map: HashMap<&str, (&str, &str)> = from_doc(rawdoc).expect("could not decode regex");
983        assert_eq!(map.get("regex").expect("no key regex").0, "^_id$");
984        assert_eq!(map.get("regex").expect("no key regex").1, "i");
985    }
986
987    #[test]
988    fn deserialize_utc_datetime_to_struct() {
989        #[derive(Deserialize)]
990        struct Dateish {
991            #[serde(with = "chrono::serde::ts_milliseconds")]
992            utc_datetime: chrono::DateTime<Utc>,
993        }
994        let mut docbytes = Vec::new();
995        let doc = doc! {"utc_datetime": Bson::DateTime(Utc::now())};
996        doc.to_writer(&mut docbytes)
997            .expect("could not encode document");
998        let rawdoc = DocBuf::new(docbytes).expect("invalid document");
999        assert!(rawdoc.get_datetime("utc_datetime").is_ok());
1000        let value: Dateish = from_doc(&rawdoc).expect("could not decode utc_datetime");
1001        let elapsed = Utc::now().signed_duration_since(value.utc_datetime);
1002        // The previous now was less than half a second ago
1003        assert!(elapsed.num_milliseconds() >= 0);
1004        assert!(elapsed.num_milliseconds() < 500);
1005    }
1006
1007    #[test]
1008    fn deserialize_utc_datetime_as_chrono_datetime() {
1009        let mut docbytes = Vec::new();
1010        let doc = doc! {"utc_datetime": Utc::now()};
1011        doc.to_writer(&mut docbytes)
1012            .expect("could not encode document");
1013        let rawdoc = DocBuf::new(docbytes).expect("invalid document");
1014        assert!(rawdoc.get_datetime("utc_datetime").is_ok());
1015        let map: HashMap<&str, DateTime> =
1016            from_doc(&rawdoc).expect("could not decode utc_datetime");
1017
1018        let dt = map.get("utc_datetime").expect("no key utc_datetime");
1019        println!("{:?}", dt);
1020        let dt = dt.0;
1021        let elapsed = Utc::now().signed_duration_since(dt);
1022        // The previous now was less than half a second ago
1023        assert!(elapsed.num_milliseconds() >= 0);
1024        assert!(elapsed.num_milliseconds() < 500);
1025    }
1026
1027    #[test]
1028    fn deserialize_object_id_as_bson() {
1029        let mut docbytes = Vec::new();
1030        let doc = doc! { "object_id": ObjectId::with_string("123456123456123456123456").unwrap() };
1031        doc.to_writer(&mut docbytes)
1032            .expect("could not encode document");
1033        let rawdoc = DocBuf::new(docbytes).expect("invalid document");
1034        assert!(rawdoc.get_object_id("object_id").is_ok());
1035        let map: HashMap<&str, Bson> = from_doc(&rawdoc).expect("could not decode object_id");
1036        assert_eq!(
1037            map.get("object_id").unwrap(),
1038            &Bson::ObjectId(ObjectId::with_string("123456123456123456123456").unwrap())
1039        );
1040    }
1041
1042    #[test]
1043    fn deserialize_utc_datetime_as_bson() {
1044        let mut docbytes = Vec::new();
1045        let doc = doc! {"utc_datetime": Utc::now()};
1046        doc.to_writer(&mut docbytes)
1047            .expect("could not encode document");
1048        let rawdoc = DocBuf::new(docbytes).expect("invalid document");
1049        assert!(rawdoc.get_datetime("utc_datetime").is_ok());
1050        let map: HashMap<&str, Bson> = from_doc(&rawdoc).expect("could not decode utc_datetime");
1051
1052        let dt = map.get("utc_datetime").expect("no key utc_datetime");
1053        let dt = dt
1054            .as_datetime()
1055            .expect("value was not of type Bson::DateTime");
1056        let elapsed = Utc::now().signed_duration_since(*dt);
1057        // The previous now was less than half a second ago
1058        assert!(elapsed.num_milliseconds() >= 0);
1059        assert!(elapsed.num_milliseconds() < 500);
1060    }
1061
1062    #[test]
1063    fn deserialize_utc_datetime_as_i64() {
1064        let mut docbytes = Vec::new();
1065        let doc = doc! {"utc_datetime": Bson::DateTime(Utc::now())};
1066        doc.to_writer(&mut docbytes)
1067            .expect("could not encode document");
1068        let rawdoc = DocBuf::new(docbytes).expect("invalid document");
1069        assert!(rawdoc.get_datetime("utc_datetime").is_ok());
1070        let map: HashMap<&str, i64> =
1071            from_doc(&rawdoc).expect("could not decode utc_datetime as i64");
1072        let _time = map.get("utc_datetime").expect("no key utc_datetime");
1073    }
1074}
rawbson/de.rs

rawbson/
de.rs
