RUST-1992 Driver changes to track bson serde-optional API changes (#1401)

Author: abr-egn

Cargo.lock

@@ -134,11 +134,12 @@ branch = "main"
 package = "bson"
 version = "3.0.0"
 optional = true
+features = ["serde"]
 
 [dependencies.mongocrypt]
 git = "https://github.com/mongodb/libmongocrypt-rust.git"
 branch = "main"
-version = "0.3.0"
+version = "0.3.1"
 default-features = false
 optional = true
 

Cargo.toml

@@ -107,7 +107,8 @@ impl<T: Serialize + DeserializeOwned + Send + Sync> Collection<T> {
         FindOneAndReplace {
             coll: self,
             filter,
-            replacement: crate::bson::to_raw_document_buf(replacement.borrow()).map_err(Into::into),
+            replacement: crate::bson_compat::serialize_to_raw_document_buf(replacement.borrow())
+                .map_err(Into::into),
             options: None,
             session: None,
         }

src/action/find_and_modify.rs

@@ -34,7 +34,10 @@ impl<T: Serialize + Send + Sync> Collection<T> {
             coll: CollRef::new(self),
             docs: docs
                 .into_iter()
-                .map(|v| crate::bson::to_raw_document_buf(v.borrow()).map_err(Into::into))
+                .map(|v| {
+                    crate::bson_compat::serialize_to_raw_document_buf(v.borrow())
+                        .map_err(Into::into)
+                })
                 .collect(),
             options: None,
             session: None,

src/action/insert_many.rs

@@ -32,7 +32,8 @@ impl<T: Serialize + Send + Sync> Collection<T> {
     pub fn insert_one(&self, doc: impl Borrow<T>) -> InsertOne {
         InsertOne {
             coll: CollRef::new(self),
-            doc: crate::bson::to_raw_document_buf(doc.borrow()).map_err(Into::into),
+            doc: crate::bson_compat::serialize_to_raw_document_buf(doc.borrow())
+                .map_err(Into::into),
             options: None,
             session: None,
         }

src/action/insert_one.rs

@@ -106,7 +106,7 @@ impl<'a> Action for ListDatabases<'a, ListSpecifications> {
             .and_then(|dbs| {
                 dbs.into_iter()
                     .map(|db_spec| {
-                        crate::bson::from_slice(db_spec.as_bytes())
+                        crate::bson_compat::deserialize_from_slice(db_spec.as_bytes())
                             .map_err(crate::error::Error::from)
                     })
                     .collect()

src/action/list_databases.rs

@@ -31,7 +31,8 @@ impl<T: Serialize + Send + Sync> Collection<T> {
         ReplaceOne {
             coll: CollRef::new(self),
             query,
-            replacement: crate::bson::to_raw_document_buf(replacement.borrow()).map_err(Into::into),
+            replacement: crate::bson_compat::serialize_to_raw_document_buf(replacement.borrow())
+                .map_err(Into::into),
             options: None,
             session: None,
         }

src/action/replace_one.rs

@@ -1,31 +1,132 @@
-#[cfg(feature = "bson-3")]
-pub(crate) trait RawDocumentBufExt {
-    fn append_ref<'a>(
+use crate::bson::RawBson;
+
+pub(crate) trait RawDocumentBufExt: Sized {
+    fn append_err(&mut self, key: impl AsRef<str>, value: impl Into<RawBson>) -> RawResult<()>;
+
+    fn append_ref_err<'a>(
         &mut self,
         key: impl AsRef<str>,
         value: impl Into<crate::bson::raw::RawBsonRef<'a>>,
-    );
+    ) -> RawResult<()>;
+
+    #[cfg(not(feature = "bson-3"))]
+    fn decode_from_bytes(data: Vec<u8>) -> RawResult<Self>;
 }
 
 #[cfg(feature = "bson-3")]
 impl RawDocumentBufExt for crate::bson::RawDocumentBuf {
-    fn append_ref<'a>(
+    fn append_err(&mut self, key: impl AsRef<str>, value: impl Into<RawBson>) -> RawResult<()> {
+        self.append(key, value.into())
+    }
+
+    fn append_ref_err<'a>(
         &mut self,
         key: impl AsRef<str>,
         value: impl Into<crate::bson::raw::RawBsonRef<'a>>,
-    ) {
+    ) -> RawResult<()> {
         self.append(key, value)
     }
 }
 
+#[cfg(not(feature = "bson-3"))]
+impl RawDocumentBufExt for crate::bson::RawDocumentBuf {
+    fn append_err(&mut self, key: impl AsRef<str>, value: impl Into<RawBson>) -> RawResult<()> {
+        self.append(key, value);
+        Ok(())
+    }
+
+    fn append_ref_err<'a>(
+        &mut self,
+        key: impl AsRef<str>,
+        value: impl Into<crate::bson::raw::RawBsonRef<'a>>,
+    ) -> RawResult<()> {
+        self.append_ref(key, value);
+        Ok(())
+    }
+
+    fn decode_from_bytes(data: Vec<u8>) -> RawResult<Self> {
+        Self::from_bytes(data)
+    }
+}
+
+pub(crate) trait RawArrayBufExt: Sized {
+    #[allow(dead_code)]
+    fn from_iter_err<V: Into<RawBson>, I: IntoIterator<Item = V>>(iter: I) -> RawResult<Self>;
+
+    fn push_err(&mut self, value: impl Into<RawBson>) -> RawResult<()>;
+}
+
 #[cfg(feature = "bson-3")]
-pub(crate) use crate::bson::error::Result as RawResult;
+impl RawArrayBufExt for crate::bson::RawArrayBuf {
+    fn from_iter_err<V: Into<RawBson>, I: IntoIterator<Item = V>>(iter: I) -> RawResult<Self> {
+        Self::from_iter(iter.into_iter().map(|v| v.into()))
+    }
+
+    fn push_err(&mut self, value: impl Into<RawBson>) -> RawResult<()> {
+        self.push(value.into())
+    }
+}
 
 #[cfg(not(feature = "bson-3"))]
-pub(crate) use crate::bson::raw::Result as RawResult;
+impl RawArrayBufExt for crate::bson::RawArrayBuf {
+    fn from_iter_err<V: Into<RawBson>, I: IntoIterator<Item = V>>(iter: I) -> RawResult<Self> {
+        Ok(Self::from_iter(iter))
+    }
 
-#[cfg(feature = "bson-3")]
-pub(crate) use crate::bson::error::Error as RawError;
+    fn push_err(&mut self, value: impl Into<RawBson>) -> RawResult<()> {
+        self.push(value);
+        Ok(())
+    }
+}
 
 #[cfg(not(feature = "bson-3"))]
-pub(crate) use crate::bson::raw::Error as RawError;
+pub(crate) trait RawDocumentExt {
+    fn decode_from_bytes<D: AsRef<[u8]> + ?Sized>(data: &D) -> RawResult<&Self>;
+}
+
+#[cfg(not(feature = "bson-3"))]
+impl RawDocumentExt for crate::bson::RawDocument {
+    fn decode_from_bytes<D: AsRef<[u8]> + ?Sized>(data: &D) -> RawResult<&Self> {
+        Self::from_bytes(data)
+    }
+}
+
+#[cfg(not(feature = "bson-3"))]
+#[allow(dead_code)]
+pub(crate) trait DocumentExt {
+    fn encode_to_vec(&self) -> crate::bson::ser::Result<Vec<u8>>;
+}
+
+#[cfg(not(feature = "bson-3"))]
+impl DocumentExt for crate::bson::Document {
+    fn encode_to_vec(&self) -> crate::bson::ser::Result<Vec<u8>> {
+        let mut out = vec![];
+        self.to_writer(&mut out)?;
+        Ok(out)
+    }
+}
+
+macro_rules! use_either {
+    ($($name:ident => $path3:path | $path2:path);+;) => {
+        $(
+            #[cfg(feature = "bson-3")]
+            pub(crate) use crate::bson::{$path3 as $name};
+
+            #[cfg(not(feature = "bson-3"))]
+            #[allow(unused_imports)]
+            pub(crate) use crate::bson::{$path2 as $name};
+        )+
+    };
+}
+
+// Exported name => bson3 import | bson2 import
+use_either! {
+    RawResult                       => error::Result                    | raw::Result;
+    RawError                        => error::Error                     | raw::Error;
+    serialize_to_raw_document_buf   => serialize_to_raw_document_buf    | to_raw_document_buf;
+    serialize_to_document           => serialize_to_document            | to_document;
+    serialize_to_bson               => serialize_to_bson                | to_bson;
+    deserialize_from_slice          => deserialize_from_slice           | from_slice;
+    deserialize_from_document       => deserialize_from_document        | from_document;
+    deserialize_from_bson           => deserialize_from_bson            | from_bson;
+}

src/bson_compat.rs

@@ -17,14 +17,12 @@ use crate::{
         RawBsonRef,
         RawDocumentBuf,
     },
+    bson_compat::{RawArrayBufExt, RawDocumentBufExt as _},
     checked::Checked,
     error::{Error, ErrorKind, Result},
     runtime::SyncLittleEndianRead,
 };
 
-#[cfg(feature = "bson-3")]
-use crate::bson_compat::RawDocumentBufExt as _;
-
 /// Coerce numeric types into an `i64` if it would be lossless to do so. If this Bson is not numeric
 /// or the conversion would be lossy (e.g. 1.5 -> 1), this returns `None`.
 #[allow(clippy::cast_possible_truncation)]
@@ -80,14 +78,14 @@ pub(crate) fn to_bson_array(docs: &[Document]) -> Bson {
 pub(crate) fn to_raw_bson_array(docs: &[Document]) -> Result<RawBson> {
     let mut array = RawArrayBuf::new();
     for doc in docs {
-        array.push(RawDocumentBuf::from_document(doc)?);
+        array.push_err(RawDocumentBuf::from_document(doc)?)?;
     }
     Ok(RawBson::Array(array))
 }
 pub(crate) fn to_raw_bson_array_ser<T: Serialize>(values: &[T]) -> Result<RawBson> {
     let mut array = RawArrayBuf::new();
     for value in values {
-        array.push(crate::bson::to_raw_document_buf(value)?);
+        array.push_err(crate::bson_compat::serialize_to_raw_document_buf(value)?)?;
     }
     Ok(RawBson::Array(array))
 }
@@ -149,12 +147,12 @@ pub(crate) fn array_entry_size_bytes(index: usize, doc_len: usize) -> Result<usi
     (Checked::new(1) + num_decimal_digits(index) + 1 + doc_len).get()
 }
 
-pub(crate) fn vec_to_raw_array_buf(docs: Vec<RawDocumentBuf>) -> RawArrayBuf {
+pub(crate) fn vec_to_raw_array_buf(docs: Vec<RawDocumentBuf>) -> Result<RawArrayBuf> {
     let mut array = RawArrayBuf::new();
     for doc in docs {
-        array.push(doc);
+        array.push_err(doc)?;
     }
-    array
+    Ok(array)
 }
 
 /// The number of digits in `n` in base 10.
@@ -202,7 +200,7 @@ pub(crate) fn extend_raw_document_buf(
                 k
             )));
         }
-        this.append(k, v.to_raw_bson());
+        this.append_err(k, v.to_raw_bson())?;
     }
     Ok(())
 }
@@ -216,13 +214,13 @@ pub(crate) fn append_ser(
     struct Helper<T> {
         value: T,
     }
-    let raw_doc = crate::bson::to_raw_document_buf(&Helper { value })?;
-    this.append_ref(
+    let raw_doc = crate::bson_compat::serialize_to_raw_document_buf(&Helper { value })?;
+    this.append_ref_err(
         key,
         raw_doc
             .get("value")?
             .ok_or_else(|| Error::internal("no value"))?,
-    );
+    )?;
     Ok(())
 }
 
@@ -243,7 +241,7 @@ pub(crate) fn get_or_prepend_id_field(doc: &mut RawDocumentBuf) -> Result<Bson>
             let new_length: i32 = Checked::new(new_bytes.len()).try_into()?;
             new_bytes[0..4].copy_from_slice(&new_length.to_le_bytes());
 
-            *doc = RawDocumentBuf::from_bytes(new_bytes)?;
+            *doc = RawDocumentBuf::decode_from_bytes(new_bytes)?;
 
             Ok(id.into())
         }

src/bson_util.rs

@@ -158,7 +158,9 @@ where
     /// ```
     pub async fn next_if_any(&mut self) -> Result<Option<T>> {
         Ok(match NextInBatchFuture::new(self).await? {
-            BatchValue::Some { doc, .. } => Some(crate::bson::from_slice(doc.as_bytes())?),
+            BatchValue::Some { doc, .. } => {
+                Some(crate::bson_compat::deserialize_from_slice(doc.as_bytes())?)
+            }
             BatchValue::Empty | BatchValue::Exhausted => None,
         })
     }

src/change_stream.rs

@@ -148,7 +148,9 @@ where
                     match bv {
                         BatchValue::Some { doc, .. } => {
                             self.data.document_returned = true;
-                            return Ok(Some(crate::bson::from_slice(doc.as_bytes())?));
+                            return Ok(Some(crate::bson_compat::deserialize_from_slice(
+                                doc.as_bytes(),
+                            )?));
                         }
                         BatchValue::Empty | BatchValue::Exhausted => return Ok(None),
                     }

src/change_stream/session.rs

@@ -14,7 +14,7 @@ mod x509;
 
 use std::{borrow::Cow, fmt::Debug, str::FromStr};
 
-use crate::bson::RawDocumentBuf;
+use crate::{bson::RawDocumentBuf, bson_compat::RawDocumentBufExt as _};
 use derive_where::derive_where;
 use hmac::{digest::KeyInit, Mac};
 use rand::Rng;
@@ -240,7 +240,7 @@ impl AuthMechanism {
                 Ok(Some(ClientFirst::Scram(ScramVersion::Sha256, client_first)))
             }
             Self::MongoDbX509 => Ok(Some(ClientFirst::X509(Box::new(
-                x509::build_speculative_client_first(credential),
+                x509::build_speculative_client_first(credential)?,
             )))),
             Self::Plain => Ok(None),
             Self::MongoDbOidc => Ok(oidc::build_speculative_client_first(credential)
@@ -447,13 +447,17 @@ impl Credential {
 
     /// If the mechanism is missing, append the appropriate mechanism negotiation key-value-pair to
     /// the provided hello or legacy hello command document.
-    pub(crate) fn append_needed_mechanism_negotiation(&self, command: &mut RawDocumentBuf) {
+    pub(crate) fn append_needed_mechanism_negotiation(
+        &self,
+        command: &mut RawDocumentBuf,
+    ) -> Result<()> {
         if let (Some(username), None) = (self.username.as_ref(), self.mechanism.as_ref()) {
-            command.append(
+            command.append_err(
                 "saslSupportedMechs",
                 format!("{}.{}", self.resolved_source(), username),
-            );
+            )?;
         }
+        Ok(())
     }
 
     /// Attempts to authenticate a stream according to this credential, returning an error
@@ -551,12 +555,12 @@ pub(crate) enum ClientFirst {
 }
 
 impl ClientFirst {
-    pub(crate) fn to_document(&self) -> RawDocumentBuf {
-        match self {
-            Self::Scram(version, client_first) => client_first.to_command(version).body,
+    pub(crate) fn to_document(&self) -> Result<RawDocumentBuf> {
+        Ok(match self {
+            Self::Scram(version, client_first) => client_first.to_command(version)?.body,
             Self::X509(command) => command.body.clone(),
             Self::Oidc(command) => command.body.clone(),
-        }
+        })
     }
 
     pub(crate) fn into_first_round(self, server_first: Document) -> FirstRound {