feat: convert collection to use serde

With BSON & MongoDB 2.0 which is clearly geared at using serde for
conversion using the interim document type for Collection no longer
makes sense. For that reason Collection has been changed to require
serde, this should not be too big an issue as customer derives can be
used to obtain the old behaviour. This change also allows for Cursor to
return concrete types addressing #2.

Author: fscc-alexkornitzer

mongod-derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mongod-derive"
-version = "0.2.2"
+version = "0.3.0"
 authors = ["Alex Kornitzer <[email protected]>"]
 edition = "2018"
 description = "An abstraction layer on mongodb"
@@ -17,7 +17,8 @@ quote = "1.0"
 syn = "1.0"
 
 [dev-dependencies]
-mongod = { version = "0.2.2", path = "../mongod" }
+mongod = { version = "0.3.0", path = "../mongod" }
+serde = "1.0" 
 
 [lib]
 proc-macro = true

mongod-derive/src/lib.rs

@@ -20,8 +20,8 @@
 //! ```
 //! # mod wrap {
 //! # use mongod_derive::Mongo;
-//! # #[derive(mongod_derive::Bson)]
-//! #[derive(Mongo)]
+//! use serde::{Deserialize, Serialize};
+//! #[derive(Mongo, Deserialize, Serialize)]
 //! #[mongo(collection = "users", field, filter, update)]
 //! pub struct User {
 //!     name: String,
@@ -143,8 +143,9 @@ pub fn derive_bson(input: TokenStream) -> TokenStream {
 /// ```
 /// # mod wrap {
 /// # use mongod_derive::Mongo;
-/// # #[derive(mongod_derive::Bson)]
-/// #[derive(Mongo)]
+/// use serde::{Deserialize, Serialize};
+///
+/// #[derive(Mongo, Deserialize, Serialize)]
 /// #[mongo(collection = "users")]
 /// pub struct User {
 ///     name: String,
@@ -228,8 +229,9 @@ pub fn derive_bson(input: TokenStream) -> TokenStream {
 /// ```
 /// # mod wrap {
 /// # use mongod_derive::Mongo;
-/// # #[derive(mongod_derive::Bson)]
-/// #[derive(Mongo)]
+/// use serde::{Deserialize, Serialize};
+///
+/// #[derive(Mongo, Deserialize, Serialize)]
 /// #[mongo(collection = "users")]
 /// pub struct User {
 ///     name: String,
@@ -246,8 +248,9 @@ pub fn derive_bson(input: TokenStream) -> TokenStream {
 /// ```
 /// # mod wrap {
 /// # use mongod_derive::Mongo;
-/// # #[derive(mongod_derive::Bson)]
-/// #[derive(Mongo)]
+/// use serde::{Deserialize, Serialize};
+///
+/// #[derive(Mongo, Deserialize, Serialize)]
 /// #[mongo(collection = "users")]
 /// pub struct User {
 ///     name: String,

mongod-derive/src/mongo.rs

@@ -58,40 +58,10 @@ fn impl_struct(
     attrs: &attr::Container,
 ) -> proc_macro2::TokenStream {
     let collection = if let Some(col) = &attrs.collection {
-        let from = if attrs.bson == attr::BsonMode::Serde {
-            quote! {
-                _mongo::bson::from_document(document).map_err(_mongo::Error::invalid_document)
-            }
-        } else {
-            quote! {
-                Self::try_from(_mongo::bson::Bson::Document(document)).map_err(_mongo::Error::invalid_document)
-            }
-        };
-        let into = if attrs.bson == attr::BsonMode::Serde {
-            quote! {
-                let b = _mongo::bson::to_bson(&self).map_err(_mongo::Error::invalid_document)?;
-            }
-        } else {
-            quote! {
-                let b = _mongo::bson::Bson::try_from(self).map_err(_mongo::Error::invalid_document)?;
-            }
-        };
         quote! {
             #[automatically_derived]
             impl _mongo::Collection for #name {
                 const COLLECTION: &'static str = #col;
-
-                fn from_document(document: _mongo::bson::Document) -> Result<Self, _mongo::Error> {
-                    #from
-                }
-
-                fn into_document(self) -> Result<_mongo::bson::Document, _mongo::Error> {
-                    #into
-                    match b {
-                        _mongo::bson::Bson::Document(doc) => Ok(doc),
-                        _ => Err(_mongo::Error::invalid_document("not a bson document")),
-                    }
-                }
             }
         }
     } else {

mongod/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "mongod"
-version = "0.2.2"
+version = "0.3.0"
 authors = [
   "Alex Kornitzer <[email protected]>",
 ]
@@ -21,14 +21,14 @@ chrono = { version = "0.4", optional = true, features = ["serde"] }
 futures = "0.3"
 log = "0.4"
 mongodb = "2.0.0-beta.3"
-mongod-derive = { version = "=0.2.2", optional = true, path = "../mongod-derive" }
+mongod-derive = { version = "=0.3.0", optional = true, path = "../mongod-derive" }
 serde = { version = "1.0", features = ["derive"] }
 tokio = { version = "1.0", default-features = false }
 url = "2.2"
 
 
 [dev-dependencies]
-mongod-derive = { version = "0.2.2", path = "../mongod-derive" }
+mongod-derive = { version = "0.3", path = "../mongod-derive" }
 
 
 [features]

mongod/src/async/client.rs

@@ -533,7 +533,7 @@ impl Client {
     /// # Errors
     ///
     /// This method fails if the mongodb encountered an error.
-    pub async fn find<C, F, T>(&self, filter: Option<F>) -> crate::Result<mongodb::Cursor<Document>>
+    pub async fn find<C, F>(&self, filter: Option<F>) -> crate::Result<mongodb::Cursor<C>>
     where
         C: AsFilter<F> + Collection,
         F: Filter,
@@ -563,8 +563,7 @@ impl Client {
         let mut cursor = find.filter(filter)?.query(&self).await?;
         if let Some(res) = cursor.next().await {
             let doc = res.map_err(crate::error::mongodb)?;
-            let document: C = C::from_document(doc).map_err(crate::error::bson)?;
-            return Ok(Some(document));
+            return Ok(Some(doc));
         }
         Ok(None)
     }

mongod/src/blocking/client.rs

@@ -10,7 +10,7 @@ use mongodb::options::{
 };
 use mongodb::results::{DeleteResult, InsertManyResult, UpdateResult};
 
-use super::cursor::Cursor;
+use super::cursor::{Cursor, CursorInt};
 use crate::collection::Collection;
 use crate::filter::{AsFilter, Filter};
 use crate::query;
@@ -167,7 +167,7 @@ pub(crate) enum Request {
 }
 pub(crate) enum Response {
     Delete(DeleteResult),
-    Find(Cursor),
+    Find(CursorInt),
     Insert(InsertManyResult),
     Replace(UpdateResult),
     Update(UpdateResult),
@@ -255,7 +255,7 @@ impl Client {
     /// # Errors
     ///
     /// This method fails if the mongodb encountered an error.
-    pub fn find<C, F>(&self, filter: Option<F>) -> crate::Result<Cursor>
+    pub fn find<C, F>(&self, filter: Option<F>) -> crate::Result<Cursor<C>>
     where
         C: AsFilter<F> + Collection,
         F: Filter,
@@ -284,8 +284,7 @@ impl Client {
         let find: query::Find<C> = query::Find::new();
         let mut cursor = find.filter(filter)?.blocking(&self)?;
         if let Some(res) = cursor.next() {
-            let doc = res.map_err(crate::error::mongodb)?;
-            let document: C = C::from_document(doc).map_err(crate::error::bson)?;
+            let document = res.map_err(crate::error::mongodb)?;
             return Ok(Some(document));
         }
         Ok(None)
@@ -489,7 +488,7 @@ impl ClientInner {
                             .map_err(crate::error::mongodb),
                             Request::Find(collection, filter, options) => {
                                 match database.collection(collection).find(filter, options).await {
-                                    Ok(c) => Ok(Response::Find(Cursor::new(c))),
+                                    Ok(c) => Ok(Response::Find(CursorInt::new(c))),
                                     Err(e) => Err(crate::error::mongodb(e)),
                                 }
                             }

mongod/src/blocking/cursor.rs

@@ -1,5 +1,8 @@
+use std::marker::{PhantomData, Unpin};
+
 use bson::Document;
 use futures::stream::StreamExt;
+use serde::de::DeserializeOwned;
 
 #[derive(Debug)]
 enum Request {
@@ -9,16 +12,11 @@ enum Response {
     Next(Option<crate::Result<Document>>),
 }
 
-/// A blocking version of the [`mongodb::Cursor`](https://docs.rs/mongodb/1.1.1/mongodb/struct.Cursor.html).
-///
-/// This wraps the async `Cursor` so that is can be called in a synchronous fashion, please see the
-/// asynchronous description for more information about the cursor.
-pub struct Cursor {
+pub(crate) struct CursorInt {
     tx: tokio::sync::mpsc::UnboundedSender<(Request, std::sync::mpsc::Sender<Response>)>,
 }
 
-impl Cursor {
-    /// Constructs a synchronous `Cursor` from an asynchronous one.
+impl CursorInt {
     pub fn new(cursor: mongodb::Cursor<Document>) -> Self {
         let (tx, mut rx) =
             tokio::sync::mpsc::unbounded_channel::<(Request, std::sync::mpsc::Sender<Response>)>();
@@ -39,10 +37,36 @@ impl Cursor {
         tokio::spawn(f);
         Self { tx }
     }
+
+    pub fn to_cursor<T>(self) -> Cursor<T>
+    where
+        T: DeserializeOwned + Unpin + Send + Sync,
+    {
+        Cursor {
+            document_type: PhantomData,
+            tx: self.tx,
+        }
+    }
+}
+
+/// A blocking version of the [`mongodb::Cursor`](https://docs.rs/mongodb/1.1.1/mongodb/struct.Cursor.html).
+///
+/// This wraps the async `Cursor` so that is can be called in a synchronous fashion, please see the
+/// asynchronous description for more information about the cursor.
+pub struct Cursor<T>
+where
+    T: DeserializeOwned + Unpin + Send + Sync,
+{
+    document_type: PhantomData<T>,
+
+    tx: tokio::sync::mpsc::UnboundedSender<(Request, std::sync::mpsc::Sender<Response>)>,
 }
 
-impl Iterator for Cursor {
-    type Item = crate::Result<Document>;
+impl<T> Iterator for Cursor<T>
+where
+    T: DeserializeOwned + Unpin + Send + Sync,
+{
+    type Item = crate::Result<T>;
     fn next(&mut self) -> Option<Self::Item> {
         let (tx, rx) = std::sync::mpsc::channel();
         self.tx
@@ -52,6 +76,11 @@ impl Iterator for Cursor {
             .recv()
             .expect("could not get response from mongo runtime");
         let Response::Next(c) = res;
-        c
+        let resp = match c {
+            Some(Ok(b)) => Some(bson::from_document::<T>(b).map_err(crate::error::mongodb)),
+            Some(Err(e)) => Some(Err(crate::error::mongodb(e))),
+            None => None,
+        };
+        resp
     }
 }

mongod/src/blocking/mod.rs

@@ -13,8 +13,9 @@
 //! example to fetch users from a collection.
 //!
 //! ```no_run
-//! # use mongod_derive::{Bson, Mongo};
-//! # #[derive(Debug, Bson, Mongo)]
+//! # use mongod_derive::Mongo;
+//! # use serde::{Deserialize, Serialize};
+//! # #[derive(Debug, Mongo, Deserialize, Serialize)]
 //! # #[mongo(collection="users", field, filter, update)]
 //! # pub struct User {
 //! #     name: String,
@@ -27,8 +28,7 @@
 //!
 //! let mut cursor = client.find::<User, _>(None).unwrap();
 //! while let Some(res) = cursor.next() {
-//!     if let Ok(doc) = res {
-//!         let user: User = User::from_document(doc).unwrap();
+//!     if let Ok(user) = res {
 //!         println!("{:?}", user);
 //!     }
 //! }