Merge branch 'main' into RUST-1529-no-ff

Author: JamieTsai1024

Cargo.lock

@@ -1,12 +1,15 @@
 # MongoDB Rust Driver
+
 [![Crates.io](https://img.shields.io/crates/v/mongodb.svg)](https://crates.io/crates/mongodb) [![docs.rs](https://docs.rs/mongodb/badge.svg)](https://docs.rs/mongodb) [![License](https://img.shields.io/badge/license-Apache%202.0-blue.svg)](https://github.com/mongodb/mongo-rust-driver/blob/main/LICENSE)
 
 This is the officially supported MongoDB Rust driver, a client side library that can be used to interact with MongoDB deployments in Rust applications. It uses the [`bson`](https://docs.rs/bson/latest) crate for BSON support. The driver contains a fully async API that requires [`tokio`](https://docs.rs/tokio). The driver also has a sync API that may be enabled via feature flags. The MongoDB Rust driver follows [semantic versioning](https://semver.org/) for its releases.
 
 For more details, including features, runnable examples, troubleshooting resources, and more, please see the [official documentation](https://www.mongodb.com/docs/drivers/rust/current/).
 
 ## Installation
+
 ### Requirements
+
 - Rust 1.82.0+ (See the [MSRV policy](#minimum-supported-rust-version-msrv-policy) for more information)
 - MongoDB 4.0+
 
@@ -15,7 +18,9 @@ For more details, including features, runnable examples, troubleshooting resourc
 The driver tests against Linux, MacOS, and Windows in CI.
 
 ### Importing
+
 The driver is available on [crates.io](https://crates.io/crates/mongodb). To use the driver in your application, simply add it to your project's `Cargo.toml`.
+
 ```toml
 [dependencies]
 mongodb = "3.2.3"
@@ -24,35 +29,45 @@ mongodb = "3.2.3"
 Version 1 of this crate has reached end of life and will no longer be receiving any updates or bug fixes, so all users are recommended to always depend on the latest 2.x release. See the [2.0.0 release notes](https://github.com/mongodb/mongo-rust-driver/releases/tag/v2.0.0) for migration information if upgrading from a 1.x version.
 
 #### Enabling the sync API
+
 The driver also provides a blocking sync API. To enable this, add the `"sync"` feature to your `Cargo.toml`:
+
 ```toml
 [dependencies.mongodb]
 version = "3.2.3"
 features = ["sync"]
 ```
+
 **Note:** The sync-specific types can be imported from `mongodb::sync` (e.g. `mongodb::sync::Client`).
 
 ### All Feature Flags
 
-| Feature                      | Description |
-|:-----------------------------|:-----------------------------|
-| `dns-resolver`               | Enable DNS resolution to allow `mongodb+srv` URI handling.  **Enabled by default.** |
-| `rustls-tls`                 | Use [`rustls`](https://docs.rs/rustls/latest/rustls/) for TLS connection handling.  **Enabled by default.** |
-| `openssl-tls`                | Use [`openssl`](https://docs.rs/openssl/latest/openssl/) for TLS connection handling. |
-| `sync`                       | Expose the synchronous API (`mongodb::sync`). |
-| `aws-auth`                   | Enable support for the MONGODB-AWS authentication mechanism. |
-| `zlib-compression`           | Enable support for compressing messages with [`zlib`](https://zlib.net/). |
-| `zstd-compression`           | Enable support for compressing messages with [`zstd`](http://facebook.github.io/zstd/). |
-| `snappy-compression`         | Enable support for compressing messages with [`snappy`](http://google.github.io/snappy/). |
-| `in-use-encryption`          | Enable support for client-side field level encryption and queryable encryption.  Note that re-exports from the `mongocrypt` crate may change in backwards-incompatible ways while that crate is below version 1.0. |
-| `tracing-unstable`           | Enable support for emitting [`tracing`](https://docs.rs/tracing/latest/tracing/) events. This API is unstable and may be subject to breaking changes in minor releases. |
-| `compat-3-0-0`               | Required for future compatibility if default features are disabled. |
+| Feature              | Description                                                                                                                                                                                                       |
+| :------------------- | :---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `dns-resolver`       | Enable DNS resolution to allow `mongodb+srv` URI handling. **Enabled by default.**                                                                                                                                |
+| `rustls-tls`         | Use [`rustls`](https://docs.rs/rustls/latest/rustls/) for TLS connection handling. **Enabled by default.**                                                                                                        |
+| `openssl-tls`        | Use [`openssl`](https://docs.rs/openssl/latest/openssl/) for TLS connection handling.                                                                                                                             |
+| `sync`               | Expose the synchronous API (`mongodb::sync`).                                                                                                                                                                     |
+| `aws-auth`           | Enable support for the MONGODB-AWS authentication mechanism.                                                                                                                                                      |
+| `zlib-compression`   | Enable support for compressing messages with [`zlib`](https://zlib.net/).                                                                                                                                         |
+| `zstd-compression`   | Enable support for compressing messages with [`zstd`](http://facebook.github.io/zstd/).                                                                                                                           |
+| `snappy-compression` | Enable support for compressing messages with [`snappy`](http://google.github.io/snappy/).                                                                                                                         |
+| `in-use-encryption`  | Enable support for client-side field level encryption and queryable encryption. Note that re-exports from the `mongocrypt` crate may change in backwards-incompatible ways while that crate is below version 1.0. |
+| `tracing-unstable`   | Enable support for emitting [`tracing`](https://docs.rs/tracing/latest/tracing/) events. This API is unstable and may be subject to breaking changes in minor releases.                                           |
+| `compat-3-0-0`       | Required for future compatibility if default features are disabled.                                                                                                                                               |
 
 ## Web Framework Examples
+
 ### Actix
+
 The driver can be used easily with the Actix web framework by storing a `Client` in Actix application data. A full example application for using MongoDB with Actix can be found [here](https://github.com/actix/examples/tree/master/databases/mongodb).
 
+### Axum
+
+A simple CRUD API example using Axum and MongoDB can be found [here](https://github.com/tokio-rs/axum/tree/main/examples/mongodb).
+
 ### Rocket
+
 The Rocket web framework provides built-in support for MongoDB via the Rust driver. The documentation for the [`rocket_db_pools`](https://api.rocket.rs/v0.5/rocket_db_pools/index.html) crate contains instructions for using MongoDB with your Rocket application.
 
 ## Note on connecting to Atlas deployments
@@ -78,7 +93,9 @@ the driver's futures directly. This will ensure the driver's futures will always
 while also allowing the application to continue in the event of a timeout.
 
 ## Bug Reporting / Feature Requests
+
 To file a bug report or submit a feature request, please open a ticket on our [Jira project](https://jira.mongodb.org/browse/RUST):
+
 - Create an account and login at [jira.mongodb.org](https://jira.mongodb.org)
 - Navigate to the RUST project at [jira.mongodb.org/browse/RUST](https://jira.mongodb.org/browse/RUST)
 - Click **Create Issue** - If the ticket you are filing is a bug report, please include as much detail as possible about the issue and how to reproduce it.
@@ -90,29 +107,38 @@ Before filing a ticket, please use the search functionality of Jira to see if a
 We encourage and would happily accept contributions in the form of GitHub pull requests. Before opening one, be sure to run the tests locally; check out the [testing section](#running-the-tests) for information on how to do that. Once you open a pull request, your branch will be run against the same testing matrix that we use for our [continuous integration](#continuous-integration) system, so it is usually sufficient to only run the integration tests locally against a standalone. Remember to always run the linter tests before opening a pull request.
 
 ## Running the tests
+
 ### Integration and unit tests
+
 In order to run the tests (which are mostly integration tests), you must have access to a MongoDB deployment. You may specify a [MongoDB connection string](https://www.mongodb.com/docs/manual/reference/connection-string/) in the `MONGODB_URI` environment variable, and the tests will use it to connect to the deployment. If `MONGODB_URI` is unset, the tests will attempt to connect to a local deployment on port 27017.
 
 **Note:** The integration tests will clear out the databases/collections they need to use, but they do not clean up after themselves.
 
 To actually run the tests, you can use `cargo` like you would in any other crate:
+
 ```bash
 cargo test --verbose # runs against localhost:27017
 export MONGODB_URI="mongodb://localhost:123"
 cargo test --verbose # runs against localhost:123
 ```
 
 #### Auth tests
+
 The authentication tests will only be included in the test run if certain requirements are met:
+
 - The deployment must have `--auth` enabled
 - Credentials must be specified in `MONGODB_URI`
 - The credentials specified in `MONGODB_URI` must be valid and have root privileges on the deployment
+
 ```bash
 export MONGODB_URI="mongodb://user:pass@localhost:27017"
 cargo test --verbose # auth tests included
 ```
+
 #### Topology-specific tests
+
 Certain tests will only be run against certain topologies. To ensure that the entire test suite is run, make sure to run the tests separately against standalone, replicated, and sharded deployments.
+
 ```bash
 export MONGODB_URI="mongodb://my-standalone-host:27017" # mongod running on 27017
 cargo test --verbose
@@ -123,28 +149,36 @@ cargo test --verbose
 ```
 
 #### Run the tests with TLS/SSL
+
 To run the tests with TLS/SSL enabled, you must enable it on the deployment and in `MONGODB_URI`.
+
 ```bash
 export MONGODB_URI="mongodb://localhost:27017/?tls=true&tlsCertificateKeyFile=cert.pem&tlsCAFile=ca.pem"
 cargo test --verbose
 ```
+
 **Note:** When you open a pull request, your code will be run against a comprehensive testing matrix, so it is usually not necessary to run the integration tests against all combinations of topology/auth/TLS locally.
 
 ### Linter Tests
+
 Our linter tests use the nightly version of `rustfmt` to verify that the source is formatted properly and the stable version of `clippy` to statically detect any common mistakes.
 You can use `rustup` to install them both:
+
 ```bash
 rustup component add clippy --toolchain stable
 rustup component add rustfmt --toolchain nightly
 ```
+
 Our linter tests also use `rustdoc` to verify that all necessary documentation is present and properly formatted. `rustdoc` is included in the standard Rust distribution.
 
 To run the linter tests, run the `check-clippy.sh`, `check-rustfmt.sh`, and `check-rustdoc.sh` scripts in the `.evergreen` directory. To run all three, use the `check-all.sh` script.
+
 ```bash
 bash .evergreen/check-all.sh
 ```
 
 ## Continuous Integration
+
 Commits to main are run automatically on [evergreen](https://evergreen.mongodb.com/waterfall/mongo-rust-driver).
 
 ## Minimum supported Rust version (MSRV) policy

README.md

@@ -6,7 +6,7 @@ use serde_with::skip_serializing_none;
 use typed_builder::TypedBuilder;
 
 use crate::{
-    bson::{doc, serde_helpers, Bson, Document, RawBson, RawDocumentBuf},
+    bson::{doc, Bson, Document, RawBson, RawDocumentBuf},
     concern::{ReadConcern, WriteConcern},
     error::Result,
     options::Collation,
@@ -1186,7 +1186,7 @@ impl Serialize for CommitQuorum {
         S: Serializer,
     {
         match self {
-            CommitQuorum::Nodes(n) => serde_helpers::serialize_u32_as_i32(n, serializer),
+            CommitQuorum::Nodes(n) => serde_util::serialize_u32_as_i32(n, serializer),
             CommitQuorum::VotingMembers => serializer.serialize_str("votingMembers"),
             CommitQuorum::Majority => serializer.serialize_str("majority"),
             CommitQuorum::Custom(s) => serializer.serialize_str(s),

src/coll/options.rs

@@ -10,7 +10,7 @@ use serde_with::skip_serializing_none;
 use typed_builder::TypedBuilder;
 
 use crate::{
-    bson::{doc, serde_helpers, Timestamp},
+    bson::{doc, Timestamp},
     error::{ErrorKind, Result},
     serde_util,
 };
@@ -244,7 +244,7 @@ impl Serialize for Acknowledgment {
     {
         match self {
             Acknowledgment::Majority => serializer.serialize_str("majority"),
-            Acknowledgment::Nodes(n) => serde_helpers::serialize_u32_as_i32(n, serializer),
+            Acknowledgment::Nodes(n) => serde_util::serialize_u32_as_i32(n, serializer),
             Acknowledgment::Custom(name) => serializer.serialize_str(name),
         }
     }

src/concern.rs

@@ -14,6 +14,7 @@ use crate::{
     checked::Checked,
     error::Error,
     options::{CollectionOptions, ReadConcern, SelectionCriteria, WriteConcern},
+    serde_util,
     Collection,
     Database,
 };
@@ -31,7 +32,7 @@ pub(crate) struct Chunk<'a> {
     #[serde(rename = "_id")]
     id: ObjectId,
     files_id: Bson,
-    #[serde(serialize_with = "crate::bson::serde_helpers::serialize_u32_as_i32")]
+    #[serde(serialize_with = "serde_util::serialize_u32_as_i32")]
     n: u32,
     #[serde(borrow)]
     data: RawBinaryRef<'a>,
@@ -54,7 +55,7 @@ pub struct FilesCollectionDocument {
     /// The size of the file's chunks in bytes.
     #[serde(
         rename = "chunkSize",
-        serialize_with = "crate::bson::serde_helpers::serialize_u32_as_i32"
+        serialize_with = "serde_util::serialize_u32_as_i32"
     )]
     pub chunk_size_bytes: u32,
 

src/gridfs.rs

@@ -1,10 +1,6 @@
 use std::time::Duration;
 
-use crate::{
-    bson::{serde_helpers, Document},
-    collation::Collation,
-    serde_util,
-};
+use crate::{bson::Document, collation::Collation, serde_util};
 
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 use typed_builder::TypedBuilder;
@@ -157,7 +153,7 @@ impl Serialize for IndexVersion {
             IndexVersion::V0 => serializer.serialize_i32(0),
             IndexVersion::V1 => serializer.serialize_i32(1),
             IndexVersion::V2 => serializer.serialize_i32(2),
-            IndexVersion::Custom(i) => serde_helpers::serialize_u32_as_i32(i, serializer),
+            IndexVersion::Custom(i) => serde_util::serialize_u32_as_i32(i, serializer),
         }
     }
 }
@@ -203,7 +199,7 @@ impl Serialize for TextIndexVersion {
             TextIndexVersion::V1 => serializer.serialize_i32(1),
             TextIndexVersion::V2 => serializer.serialize_i32(2),
             TextIndexVersion::V3 => serializer.serialize_i32(3),
-            TextIndexVersion::Custom(i) => serde_helpers::serialize_u32_as_i32(i, serializer),
+            TextIndexVersion::Custom(i) => serde_util::serialize_u32_as_i32(i, serializer),
         }
     }
 }
@@ -244,7 +240,7 @@ impl Serialize for Sphere2DIndexVersion {
         match self {
             Sphere2DIndexVersion::V2 => serializer.serialize_i32(2),
             Sphere2DIndexVersion::V3 => serializer.serialize_i32(3),
-            Sphere2DIndexVersion::Custom(i) => serde_helpers::serialize_u32_as_i32(i, serializer),
+            Sphere2DIndexVersion::Custom(i) => serde_util::serialize_u32_as_i32(i, serializer),
         }
     }
 }

src/index/options.rs

@@ -8,7 +8,7 @@ use serde::{Deserialize, Serialize};
 use serde_with::skip_serializing_none;
 
 use crate::{
-    bson::{serde_helpers, Binary, Bson, Document, RawDocumentBuf},
+    bson::{Binary, Bson, Document, RawDocumentBuf},
     change_stream::event::ResumeToken,
     db::options::CreateCollectionOptions,
     serde_util,
@@ -53,11 +53,11 @@ pub struct InsertManyResult {
 #[non_exhaustive]
 pub struct UpdateResult {
     /// The number of documents that matched the filter.
-    #[serde(serialize_with = "crate::bson::serde_helpers::serialize_u64_as_i64")]
+    #[serde(serialize_with = "serde_util::serialize_u64_as_i64")]
     pub matched_count: u64,
 
     /// The number of documents that were modified by the operation.
-    #[serde(serialize_with = "crate::bson::serde_helpers::serialize_u64_as_i64")]
+    #[serde(serialize_with = "serde_util::serialize_u64_as_i64")]
     pub modified_count: u64,
 
     /// The `_id` field of the upserted document.
@@ -71,7 +71,7 @@ pub struct UpdateResult {
 #[non_exhaustive]
 pub struct DeleteResult {
     /// The number of documents deleted by the operation.
-    #[serde(serialize_with = "crate::bson::serde_helpers::serialize_u64_as_i64")]
+    #[serde(serialize_with = "serde_util::serialize_u64_as_i64")]
     pub deleted_count: u64,
 }
 
@@ -182,7 +182,7 @@ pub struct DatabaseSpecification {
     /// The amount of disk space in bytes that is consumed by the database.
     #[serde(
         deserialize_with = "serde_util::deserialize_u64_from_bson_number",
-        serialize_with = "serde_helpers::serialize_u64_as_i64"
+        serialize_with = "serde_util::serialize_u64_as_i64"
     )]
     pub size_on_disk: u64,
 

src/results.rs

@@ -7,6 +7,7 @@ use crate::{
     bson_util::get_u64,
     error::{Error, Result},
     options::WriteConcern,
+    serde_util,
 };
 
 pub(crate) mod duration_option_as_int_seconds {
@@ -73,7 +74,7 @@ pub(crate) fn serialize_u32_option_as_i32<S: Serializer>(
     serializer: S,
 ) -> std::result::Result<S::Ok, S::Error> {
     match val {
-        Some(ref val) => crate::bson::serde_helpers::serialize_u32_as_i32(val, serializer),
+        Some(ref val) => serde_util::serialize_u32_as_i32(val, serializer),
         None => serializer.serialize_none(),
     }
 }
@@ -101,7 +102,7 @@ pub(crate) fn serialize_u64_option_as_i64<S: Serializer>(
     serializer: S,
 ) -> std::result::Result<S::Ok, S::Error> {
     match val {
-        Some(ref v) => crate::bson::serde_helpers::serialize_u64_as_i64(v, serializer),
+        Some(ref v) => serde_util::serialize_u64_as_i64(v, serializer),
         None => serializer.serialize_none(),
     }
 }
@@ -225,3 +226,29 @@ pub(crate) fn serialize_bool_or_true<S: Serializer>(
     let val = val.unwrap_or(true);
     serializer.serialize_bool(val)
 }
+
+pub(crate) fn serialize_u32_as_i32<S: Serializer>(
+    n: &u32,
+    serializer: S,
+) -> std::result::Result<S::Ok, S::Error> {
+    match i32::try_from(*n) {
+        Ok(n) => n.serialize(serializer),
+        Err(_) => Err(serde::ser::Error::custom(format!(
+            "cannot serialize u32 {} as i32",
+            n
+        ))),
+    }
+}
+
+pub(crate) fn serialize_u64_as_i64<S: Serializer>(
+    n: &u64,
+    serializer: S,
+) -> std::result::Result<S::Ok, S::Error> {
+    match i64::try_from(*n) {
+        Ok(n) => n.serialize(serializer),
+        Err(_) => Err(serde::ser::Error::custom(format!(
+            "cannot serialize u64 {} as i64",
+            n
+        ))),
+    }
+}