feat: undo the serde only approach

On reflection it makes more sense to keep with the original approach at
the cost of one additional layer of type conversion. I think for the
serde approach to make sense then we would have to go all in with it,
not do half and half.

Author: fscc-alexkornitzer

mongod-derive/src/lib.rs

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

mongod-derive/src/mongo.rs

@@ -58,10 +58,40 @@ 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/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>(&self, filter: Option<F>) -> crate::Result<mongodb::Cursor<C>>
+    pub async fn find<C, F>(&self, filter: Option<F>) -> crate::Result<mongodb::Cursor<Document>>
     where
         C: AsFilter<F> + Collection,
         F: Filter,
@@ -563,6 +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 doc = C::from_document(doc)?;
             return Ok(Some(doc));
         }
         Ok(None)

mongod/src/async/cursor.rs

@@ -0,0 +1,53 @@
+use std::marker::PhantomData;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use bson::Document;
+use futures::Stream;
+use mongodb::Cursor;
+
+use crate::collection::Collection;
+
+/// A typed blocking cursor.
+///
+/// This wraps the blocking `Cursor` so that is can be automatically return typed documents.
+pub struct TypedCursor<T>
+where
+    T: Collection,
+{
+    cursor: Cursor<Document>,
+    document_type: PhantomData<T>,
+}
+
+impl<T> From<Cursor<Document>> for TypedCursor<T>
+where
+    T: Collection,
+{
+    fn from(cursor: Cursor<Document>) -> Self {
+        TypedCursor {
+            cursor: cursor,
+            document_type: PhantomData,
+        }
+    }
+}
+
+impl<T> Stream for TypedCursor<T>
+where
+    T: Collection,
+{
+    type Item = crate::Result<T>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let next = Pin::new(&mut self.cursor).poll_next(cx);
+        match next {
+            Poll::Ready(opt) => Poll::Ready(opt.map(|result| {
+                result
+                    .map_err(crate::error::mongodb)
+                    .and_then(|doc| T::from_document(doc))
+            })),
+            Poll::Pending => Poll::Pending,
+        }
+    }
+}
+
+impl<T> Unpin for TypedCursor<T> where T: Collection {}

mongod/src/async/mod.rs

@@ -1,3 +1,5 @@
 pub use self::client::{Client, ClientBuilder};
+pub use self::cursor::TypedCursor;
 
 pub mod client;
+mod cursor;

mongod/src/blocking/client.rs

@@ -10,7 +10,7 @@ use mongodb::options::{
 };
 use mongodb::results::{DeleteResult, InsertManyResult, UpdateResult};
 
-use super::cursor::{Cursor, CursorInt};
+use super::cursor::Cursor;
 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(CursorInt),
+    Find(Cursor),
     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<C>>
+    pub fn find<C, F>(&self, filter: Option<F>) -> crate::Result<Cursor>
     where
         C: AsFilter<F> + Collection,
         F: Filter,
@@ -285,6 +285,7 @@ impl Client {
         let mut cursor = find.filter(filter)?.blocking(&self)?;
         if let Some(res) = cursor.next() {
             let document = res.map_err(crate::error::mongodb)?;
+            let document = C::from_document(document)?;
             return Ok(Some(document));
         }
         Ok(None)
@@ -488,7 +489,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(CursorInt::new(c))),
+                                    Ok(c) => Ok(Response::Find(Cursor::new(c))),
                                     Err(e) => Err(crate::error::mongodb(e)),
                                 }
                             }

mongod/src/blocking/cursor.rs

@@ -1,8 +1,9 @@
-use std::marker::{PhantomData, Unpin};
+use std::marker::PhantomData;
 
 use bson::Document;
 use futures::stream::StreamExt;
-use serde::de::DeserializeOwned;
+
+use crate::collection::Collection;
 
 #[derive(Debug)]
 enum Request {
@@ -12,12 +13,16 @@ enum Response {
     Next(Option<crate::Result<Document>>),
 }
 
-pub(crate) struct CursorInt {
+/// 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 {
     tx: tokio::sync::mpsc::UnboundedSender<(Request, std::sync::mpsc::Sender<Response>)>,
 }
 
-impl CursorInt {
-    pub fn new(cursor: mongodb::Cursor<Document>) -> Self {
+impl Cursor {
+    pub(crate) fn new(cursor: mongodb::Cursor<Document>) -> Self {
         let (tx, mut rx) =
             tokio::sync::mpsc::unbounded_channel::<(Request, std::sync::mpsc::Sender<Response>)>();
         let f = async move {
@@ -37,34 +42,50 @@ impl CursorInt {
         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,
-        }
+impl Iterator for Cursor {
+    type Item = crate::Result<Document>;
+    fn next(&mut self) -> Option<Self::Item> {
+        let (tx, rx) = std::sync::mpsc::channel();
+        self.tx
+            .send((Request::Next, tx))
+            .expect("core thread panicked");
+        let res = rx
+            .recv()
+            .expect("could not get response from mongo runtime");
+        let Response::Next(c) = res;
+        c
     }
 }
 
-/// A blocking version of the [`mongodb::Cursor`](https://docs.rs/mongodb/1.1.1/mongodb/struct.Cursor.html).
+/// A typed blocking cursor.
 ///
-/// 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>
+/// This wraps the blocking `Cursor` so that is can be automatically return typed documents.
+pub struct TypedCursor<T>
 where
-    T: DeserializeOwned + Unpin + Send + Sync,
+    T: Collection,
 {
     document_type: PhantomData<T>,
 
     tx: tokio::sync::mpsc::UnboundedSender<(Request, std::sync::mpsc::Sender<Response>)>,
 }
 
-impl<T> Iterator for Cursor<T>
+impl<T> From<Cursor> for TypedCursor<T>
+where
+    T: Collection,
+{
+    fn from(cursor: Cursor) -> Self {
+        TypedCursor {
+            document_type: PhantomData,
+            tx: cursor.tx,
+        }
+    }
+}
+
+impl<T> Iterator for TypedCursor<T>
 where
-    T: DeserializeOwned + Unpin + Send + Sync,
+    T: Collection,
 {
     type Item = crate::Result<T>;
     fn next(&mut self) -> Option<Self::Item> {
@@ -77,7 +98,7 @@ where
             .expect("could not get response from mongo runtime");
         let Response::Next(c) = res;
         let resp = match c {
-            Some(Ok(b)) => Some(bson::from_document::<T>(b).map_err(crate::error::mongodb)),
+            Some(Ok(b)) => Some(T::from_document(b)),
             Some(Err(e)) => Some(Err(crate::error::mongodb(e))),
             None => None,
         };

mongod/src/blocking/mod.rs

@@ -13,9 +13,8 @@
 //! example to fetch users from a collection.
 //!
 //! ```no_run
-//! # use mongod_derive::Mongo;
-//! # use serde::{Deserialize, Serialize};
-//! # #[derive(Debug, Mongo, Deserialize, Serialize)]
+//! # use mongod_derive::{Bson, Mongo};
+//! # #[derive(Debug, Bson, Mongo)]
 //! # #[mongo(collection="users", field, filter, update)]
 //! # pub struct User {
 //! #     name: String,