RUST-2228 Sync the driver to the BSON conversion API changes (#1437)

abr-egn · web-flow · commit eee7cdf51034 · 2025-07-31T16:52:35.000+01:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/src/action/run_command.rs b/src/action/run_command.rs
@@ -41,7 +41,7 @@ impl Database {
     pub fn run_command(&self, command: Document) -> RunCommand {
         RunCommand {
             db: self,
-            command: RawDocumentBuf::from_document(&command),
+            command: RawDocumentBuf::try_from(&command),
             options: None,
             session: None,
         }
@@ -76,7 +76,7 @@ impl Database {
     pub fn run_cursor_command(&self, command: Document) -> RunCursorCommand {
         RunCursorCommand {
             db: self,
-            command: RawDocumentBuf::from_document(&command),
+            command: RawDocumentBuf::try_from(&command),
             options: None,
             session: ImplicitSession,
         }
diff --git a/src/bson_compat.rs b/src/bson_compat.rs
@@ -29,20 +29,18 @@ pub(crate) fn cstr_to_str(cs: &CStr) -> &str {
     }
 }
 
+#[cfg(feature = "bson-3")]
 pub(crate) trait RawDocumentBufExt: Sized {
-    fn append_ref_compat<'a>(
+    fn append_ref<'a>(
         &mut self,
         key: impl AsRef<CStr>,
         value: impl Into<crate::bson::raw::RawBsonRef<'a>> + 'a,
     );
-
-    #[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_compat<'a>(
+    fn append_ref<'a>(
         &mut self,
         key: impl AsRef<CStr>,
         value: impl Into<crate::bson::raw::RawBsonRef<'a>> + 'a,
@@ -51,45 +49,15 @@ impl RawDocumentBufExt for crate::bson::RawDocumentBuf {
     }
 }
 
-#[cfg(not(feature = "bson-3"))]
-impl RawDocumentBufExt for crate::bson::RawDocumentBuf {
-    fn append_ref_compat<'a>(
-        &mut self,
-        key: impl AsRef<CStr>,
-        value: impl Into<crate::bson::raw::RawBsonRef<'a>>,
-    ) {
-        self.append_ref(key, value)
-    }
-
-    fn decode_from_bytes(data: Vec<u8>) -> RawResult<Self> {
-        Self::from_bytes(data)
-    }
-}
-
-#[cfg(not(feature = "bson-3"))]
-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(feature = "bson-3")]
+pub(crate) trait RawBsonRefExt {
+    fn to_raw_bson(&self) -> crate::bson::RawBson;
 }
 
-#[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)
+#[cfg(feature = "bson-3")]
+impl RawBsonRefExt for crate::bson::RawBsonRef<'_> {
+    fn to_raw_bson(&self) -> crate::bson::RawBson {
+        (*self).into()
     }
 }
 
@@ -113,6 +81,7 @@ use_either! {
     RawError                        => error::Error                     | raw::Error;
     DeError                         => error::Error                     | de::Error;
     SerError                        => error::Error                     | ser::Error;
+    Utf8Lossy                       => Utf8Lossy                        | serde_helpers::Utf8LossyDeserialization;
     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;
diff --git a/src/bson_util.rs b/src/bson_util.rs
@@ -6,6 +6,8 @@ use std::{
 
 use serde::Serialize;
 
+#[cfg(feature = "bson-3")]
+use crate::bson_compat::{RawBsonRefExt as _, RawDocumentBufExt as _};
 use crate::{
     bson::{
         oid::ObjectId,
@@ -17,7 +19,6 @@ use crate::{
         RawBsonRef,
         RawDocumentBuf,
     },
-    bson_compat::RawDocumentBufExt as _,
     checked::Checked,
     error::{Error, ErrorKind, Result},
     runtime::SyncLittleEndianRead,
@@ -78,7 +79,7 @@ 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(RawDocumentBuf::try_from(doc)?);
     }
     Ok(RawBson::Array(array))
 }
@@ -215,7 +216,7 @@ pub(crate) fn append_ser(
         value: T,
     }
     let raw_doc = crate::bson_compat::serialize_to_raw_document_buf(&Helper { value })?;
-    this.append_ref_compat(
+    this.append_ref(
         key,
         raw_doc
             .get("value")?
@@ -241,7 +242,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::decode_from_bytes(new_bytes)?;
+            *doc = RawDocumentBuf::from_bytes(new_bytes)?;
 
             Ok(id.into())
         }
diff --git a/src/change_stream.rs b/src/change_stream.rs
@@ -20,6 +20,8 @@ use serde::de::DeserializeOwned;
 #[cfg(test)]
 use tokio::sync::oneshot;
 
+#[cfg(feature = "bson-3")]
+use crate::bson_compat::RawBsonRefExt as _;
 use crate::{
     change_stream::event::{ChangeStreamEvent, ResumeToken},
     cursor::{stream_poll_next, BatchValue, CursorStream, NextInBatchFuture},
diff --git a/src/client/auth/aws.rs b/src/client/auth/aws.rs
@@ -25,9 +25,6 @@ use crate::{
     serde_util,
 };
 
-#[cfg(not(feature = "bson-3"))]
-use crate::bson_compat::DocumentExt as _;
-
 const AWS_ECS_IP: &str = "169.254.170.2";
 const AWS_EC2_IP: &str = "169.254.169.254";
 const AWS_LONG_DATE_FMT: &str = "%Y%m%dT%H%M%SZ";
@@ -75,7 +72,8 @@ async fn authenticate_stream_inner(
         // channel binding is not supported.
         "p": 110i32,
     };
-    let client_first_payload_bytes = client_first_payload.encode_to_vec()?;
+    let mut client_first_payload_bytes = vec![];
+    client_first_payload.to_writer(&mut client_first_payload_bytes)?;
 
     let sasl_start = SaslStart::new(
         source.into(),
@@ -125,7 +123,8 @@ async fn authenticate_stream_inner(
         client_second_payload.insert("t", security_token);
     }
 
-    let client_second_payload_bytes = client_second_payload.encode_to_vec()?;
+    let mut client_second_payload_bytes = vec![];
+    client_second_payload.to_writer(&mut client_second_payload_bytes)?;
 
     let sasl_continue = SaslContinue::new(
         source.into(),
diff --git a/src/client/csfle/client_encryption.rs b/src/client/csfle/client_encryption.rs
@@ -9,6 +9,8 @@ use mongocrypt::{ctx::KmsProvider, Crypt};
 use serde::{Deserialize, Serialize};
 use typed_builder::TypedBuilder;
 
+#[cfg(feature = "bson-3")]
+use crate::bson_compat::RawBsonRefExt as _;
 use crate::{
     bson::{doc, spec::BinarySubtype, Binary, RawBinaryRef, RawDocumentBuf},
     client::options::TlsOptions,
diff --git a/src/client/csfle/client_encryption/encrypt.rs b/src/client/csfle/client_encryption/encrypt.rs
@@ -54,9 +54,7 @@ impl<'a> Action for Encrypt<'a, Expression> {
         let doc_ref = result
             .get_document("v")
             .map_err(|e| Error::internal(format!("invalid encryption result: {}", e)))?;
-        let doc = doc_ref
-            .to_owned()
-            .to_document()
+        let doc = Document::try_from(doc_ref.to_owned())
             .map_err(|e| Error::internal(format!("invalid encryption result: {}", e)))?;
         Ok(doc)
     }
diff --git a/src/client/csfle/state_machine.rs b/src/client/csfle/state_machine.rs
@@ -125,7 +125,7 @@ impl CryptExecutor {
                 }
                 State::NeedMongoMarkings => {
                     let ctx = result_mut(&mut ctx)?;
-                    let command = ctx.mongo_op()?.to_raw_document_buf();
+                    let command = ctx.mongo_op()?.to_owned();
                     let db = db.as_ref().ok_or_else(|| {
                         Error::internal("db required for NeedMongoMarkings state")
                     })?;
diff --git a/src/client/executor.rs b/src/client/executor.rs
@@ -1,8 +1,6 @@
 #[cfg(feature = "in-use-encryption")]
 use crate::bson::RawDocumentBuf;
 use crate::bson::{doc, RawBsonRef, RawDocument, Timestamp};
-#[cfg(not(feature = "bson-3"))]
-use crate::bson_compat::RawDocumentExt as _;
 #[cfg(feature = "in-use-encryption")]
 use futures_core::future::BoxFuture;
 use once_cell::sync::Lazy;
@@ -823,7 +821,7 @@ impl Client {
         is_sharded: bool,
         response: RawCommandResponse,
     ) -> Result<RawCommandResponse> {
-        let raw_doc = RawDocument::decode_from_bytes(response.as_bytes())?;
+        let raw_doc = RawDocument::from_bytes(response.as_bytes())?;
 
         let ok = match raw_doc.get("ok")? {
             Some(b) => {
diff --git a/src/client/options/bulk_write.rs b/src/client/options/bulk_write.rs
@@ -386,7 +386,7 @@ impl WriteModel {
 
         let (mut model_document, inserted_id) = match self {
             Self::InsertOne(model) => {
-                let mut insert_document = RawDocumentBuf::from_document(&model.document)?;
+                let mut insert_document = RawDocumentBuf::try_from(&model.document)?;
                 let inserted_id = get_or_prepend_id_field(&mut insert_document)?;
                 (rawdoc! { "document": insert_document }, Some(inserted_id))
             }
diff --git a/src/cmap/conn/command.rs b/src/cmap/conn/command.rs
@@ -185,13 +185,11 @@ pub(crate) struct RawCommandResponse {
 impl RawCommandResponse {
     #[cfg(test)]
     pub(crate) fn with_document_and_address(source: ServerAddress, doc: Document) -> Result<Self> {
-        #[cfg(not(feature = "bson-3"))]
-        use crate::bson_compat::{DocumentExt as _, RawDocumentBufExt as _};
-
-        let raw = doc.encode_to_vec()?;
+        let mut raw = vec![];
+        doc.to_writer(&mut raw)?;
         Ok(Self {
             source,
-            raw: RawDocumentBuf::decode_from_bytes(raw)?,
+            raw: RawDocumentBuf::from_bytes(raw)?,
         })
     }
 
diff --git a/src/cmap/conn/wire/message.rs b/src/cmap/conn/wire/message.rs
@@ -96,15 +96,15 @@ impl Message {
     /// Gets this message's command as a Document. If serialization fails, returns a document
     /// containing the error.
     pub(crate) fn get_command_document(&self) -> Document {
-        let mut command = match self.document_payload.to_document() {
+        let mut command = match Document::try_from(self.document_payload.as_ref()) {
             Ok(document) => document,
             Err(error) => return doc! { "serialization error": error.to_string() },
         };
 
         for document_sequence in &self.document_sequences {
             let mut documents = Array::new();
             for document in &document_sequence.documents {
-                match document.to_document() {
+                match Document::try_from(document.as_ref()) {
                     Ok(document) => documents.push(document.into()),
                     Err(error) => return doc! { "serialization error": error.to_string() },
                 }
@@ -424,14 +424,11 @@ enum MessageSection {
 impl MessageSection {
     /// Reads bytes from `reader` and deserializes them into a MessageSection.
     fn read<R: Read>(reader: &mut R) -> Result<Self> {
-        #[cfg(not(feature = "bson-3"))]
-        use crate::bson_compat::RawDocumentBufExt as _;
-
         let payload_type = reader.read_u8_sync()?;
 
         if payload_type == 0 {
             let bytes = bson_util::read_document_bytes(reader)?;
-            let document = RawDocumentBuf::decode_from_bytes(bytes)?;
+            let document = RawDocumentBuf::from_bytes(bytes)?;
             return Ok(MessageSection::Document(document));
         }
 
@@ -446,7 +443,7 @@ impl MessageSection {
 
         while length_remaining.get()? > count_reader.bytes_read() {
             let bytes = bson_util::read_document_bytes(&mut count_reader)?;
-            let document = RawDocumentBuf::decode_from_bytes(bytes)?;
+            let document = RawDocumentBuf::from_bytes(bytes)?;
             documents.push(document);
         }
 
diff --git a/src/coll/options.rs b/src/coll/options.rs
@@ -81,7 +81,7 @@ pub enum Hint {
 impl Hint {
     pub(crate) fn to_raw_bson(&self) -> Result<RawBson> {
         Ok(match self {
-            Hint::Keys(ref d) => RawBson::Document(RawDocumentBuf::from_document(d)?),
+            Hint::Keys(ref d) => RawBson::Document(RawDocumentBuf::try_from(d)?),
             Hint::Name(ref s) => RawBson::String(s.clone()),
         })
     }
diff --git a/src/operation.rs b/src/operation.rs
@@ -469,15 +469,15 @@ impl<'de, T: Deserialize<'de>> Deserialize<'de> for WriteResponseBody<T> {
     where
         D: serde::Deserializer<'de>,
     {
-        use bson::serde_helpers::Utf8LossyDeserialization;
+        use crate::bson_compat::Utf8Lossy;
         #[derive(Deserialize)]
         struct Helper<T> {
             #[serde(flatten)]
             body: T,
             #[serde(rename = "writeErrors")]
-            write_errors: Option<Utf8LossyDeserialization<Vec<IndexedWriteError>>>,
+            write_errors: Option<Utf8Lossy<Vec<IndexedWriteError>>>,
             #[serde(rename = "writeConcernError")]
-            write_concern_error: Option<Utf8LossyDeserialization<WriteConcernError>>,
+            write_concern_error: Option<Utf8Lossy<WriteConcernError>>,
             #[serde(rename = "errorLabels")]
             labels: Option<Vec<String>>,
         }
diff --git a/src/operation/distinct.rs b/src/operation/distinct.rs
@@ -44,7 +44,7 @@ impl OperationWithDefaults for Distinct {
         let mut body = rawdoc! {
             Self::NAME: self.ns.coll.clone(),
             "key": self.field_name.clone(),
-            "query": RawDocumentBuf::from_document(&self.query)?,
+            "query": RawDocumentBuf::try_from(&self.query)?,
         };
 
         append_options_to_raw_document(&mut body, self.options.as_ref())?;
diff --git a/src/operation/find_and_modify.rs b/src/operation/find_and_modify.rs
@@ -72,7 +72,7 @@ impl<T: DeserializeOwned> OperationWithDefaults for FindAndModify<T> {
 
         let mut body = rawdoc! {
             Self::NAME: self.ns.coll.clone(),
-            "query": RawDocumentBuf::from_document(&self.query)?,
+            "query": RawDocumentBuf::try_from(&self.query)?,
         };
 
         match &self.modification {
diff --git a/src/operation/update.rs b/src/operation/update.rs
diff --git a/src/sdam/monitor.rs b/src/sdam/monitor.rs
diff --git a/src/test/spec/unified_runner/operation/csfle.rs b/src/test/spec/unified_runner/operation/csfle.rs

Original file line number	Diff line number	Diff line change
`@@ -125,7 +125,7 @@ impl CryptExecutor {`
`125`	`125`	`}`
`126`	`126`	`State::NeedMongoMarkings => {`
`127`	`127`	`let ctx = result_mut(&mut ctx)?;`
`128`		`- let command = ctx.mongo_op()?.to_raw_document_buf();`
	`128`	`+ let command = ctx.mongo_op()?.to_owned();`
`129`	`129`	`let db = db.as_ref().ok_or_else(\|\| {`
`130`	`130`	`Error::internal("db required for NeedMongoMarkings state")`
`131`	`131`	`})?;`